method2testcases
stringlengths 118
6.63k
|
|---|
### Question:
StreamPartitionAssignor implements PartitionAssignor, Configurable { @Override public void onAssignment(Assignment assignment) { List<TopicPartition> partitions = new ArrayList<>(assignment.partitions()); Collections.sort(partitions, PARTITION_COMPARATOR); AssignmentInfo info = AssignmentInfo.decode(assignment.userData()); this.standbyTasks = info.standbyTasks; this.activeTasks = new HashMap<>(); if (partitions.size() != info.activeTasks.size()) { throw new TaskAssignmentException( String.format("stream-thread [%s] Number of assigned partitions %d is not equal to the number of active taskIds %d" + ", assignmentInfo=%s", streamThread.getName(), partitions.size(), info.activeTasks.size(), info.toString()) ); } for (int i = 0; i < partitions.size(); i++) { TopicPartition partition = partitions.get(i); TaskId id = info.activeTasks.get(i); Set<TopicPartition> assignedPartitions = activeTasks.get(id); if (assignedPartitions == null) { assignedPartitions = new HashSet<>(); activeTasks.put(id, assignedPartitions); } assignedPartitions.add(partition); } this.partitionsByHostState = info.partitionsByHost; final Collection<Set<TopicPartition>> values = partitionsByHostState.values(); final Map<TopicPartition, PartitionInfo> topicToPartitionInfo = new HashMap<>(); for (Set<TopicPartition> value : values) { for (TopicPartition topicPartition : value) { topicToPartitionInfo.put(topicPartition, new PartitionInfo(topicPartition.topic(), topicPartition.partition(), null, new Node[0], new Node[0])); } } metadataWithInternalTopics = Cluster.empty().withPartitions(topicToPartitionInfo); checkForNewTopicAssignments(assignment); } @Override void configure(Map<String, ?> configs); @Override String name(); @Override Subscription subscription(Set<String> topics); @Override Map<String, Assignment> assign(Cluster metadata, Map<String, Subscription> subscriptions); @Override void onAssignment(Assignment assignment); void close(); final static int NOT_AVAILABLE; }### Answer:
@Test public void testOnAssignment() throws Exception { TopicPartition t2p3 = new TopicPartition("topic2", 3); TopologyBuilder builder = new TopologyBuilder(); builder.addSource("source1", "topic1"); builder.addSource("source2", "topic2"); builder.addProcessor("processor", new MockProcessorSupplier(), "source1", "source2"); UUID uuid = UUID.randomUUID(); String client1 = "client1"; StreamThread thread = new StreamThread(builder, config, mockClientSupplier, "test", client1, uuid, new Metrics(), Time.SYSTEM, new StreamsMetadataState(builder, StreamsMetadataState.UNKNOWN_HOST), 0); partitionAssignor.configure(config.getConsumerConfigs(thread, "test", client1)); List<TaskId> activeTaskList = Utils.mkList(task0, task3); Map<TaskId, Set<TopicPartition>> activeTasks = new HashMap<>(); Map<TaskId, Set<TopicPartition>> standbyTasks = new HashMap<>(); activeTasks.put(task0, Utils.mkSet(t1p0)); activeTasks.put(task3, Utils.mkSet(t2p3)); standbyTasks.put(task1, Utils.mkSet(t1p0)); standbyTasks.put(task2, Utils.mkSet(t2p0)); AssignmentInfo info = new AssignmentInfo(activeTaskList, standbyTasks, new HashMap<HostInfo, Set<TopicPartition>>()); PartitionAssignor.Assignment assignment = new PartitionAssignor.Assignment(Utils.mkList(t1p0, t2p3), info.encode()); partitionAssignor.onAssignment(assignment); assertEquals(activeTasks, partitionAssignor.activeTasks()); assertEquals(standbyTasks, partitionAssignor.standbyTasks()); } |
### Question:
StreamPartitionAssignor implements PartitionAssignor, Configurable { Cluster clusterMetadata() { if (metadataWithInternalTopics == null) { return Cluster.empty(); } return metadataWithInternalTopics; } @Override void configure(Map<String, ?> configs); @Override String name(); @Override Subscription subscription(Set<String> topics); @Override Map<String, Assignment> assign(Cluster metadata, Map<String, Subscription> subscriptions); @Override void onAssignment(Assignment assignment); void close(); final static int NOT_AVAILABLE; }### Answer:
@Test public void shouldReturnEmptyClusterMetadataIfItHasntBeenBuilt() throws Exception { final Cluster cluster = partitionAssignor.clusterMetadata(); assertNotNull(cluster); } |
### Question:
ConnectorsResource { @DELETE @Path("/{connector}") public void destroyConnector(final @PathParam("connector") String connector, final @QueryParam("forward") Boolean forward) throws Throwable { FutureCallback<Herder.Created<ConnectorInfo>> cb = new FutureCallback<>(); herder.deleteConnectorConfig(connector, cb); completeOrForwardRequest(cb, "/connectors/" + connector, "DELETE", null, forward); } ConnectorsResource(Herder herder); @GET @Path("/") Collection<String> listConnectors(final @QueryParam("forward") Boolean forward); @POST @Path("/") Response createConnector(final @QueryParam("forward") Boolean forward,
final CreateConnectorRequest createRequest); @GET @Path("/{connector}") ConnectorInfo getConnector(final @PathParam("connector") String connector,
final @QueryParam("forward") Boolean forward); @GET @Path("/{connector}/config") Map<String, String> getConnectorConfig(final @PathParam("connector") String connector,
final @QueryParam("forward") Boolean forward); @GET @Path("/{connector}/status") ConnectorStateInfo getConnectorStatus(final @PathParam("connector") String connector); @PUT @Path("/{connector}/config") Response putConnectorConfig(final @PathParam("connector") String connector,
final @QueryParam("forward") Boolean forward,
final Map<String, String> connectorConfig); @POST @Path("/{connector}/restart") void restartConnector(final @PathParam("connector") String connector,
final @QueryParam("forward") Boolean forward); @PUT @Path("/{connector}/pause") Response pauseConnector(@PathParam("connector") String connector); @PUT @Path("/{connector}/resume") Response resumeConnector(@PathParam("connector") String connector); @GET @Path("/{connector}/tasks") List<TaskInfo> getTaskConfigs(final @PathParam("connector") String connector,
final @QueryParam("forward") Boolean forward); @POST @Path("/{connector}/tasks") void putTaskConfigs(final @PathParam("connector") String connector,
final @QueryParam("forward") Boolean forward,
final List<Map<String, String>> taskConfigs); @GET @Path("/{connector}/tasks/{task}/status") ConnectorStateInfo.TaskState getTaskStatus(final @PathParam("connector") String connector,
final @PathParam("task") Integer task); @POST @Path("/{connector}/tasks/{task}/restart") void restartTask(final @PathParam("connector") String connector,
final @PathParam("task") Integer task,
final @QueryParam("forward") Boolean forward); @DELETE @Path("/{connector}") void destroyConnector(final @PathParam("connector") String connector,
final @QueryParam("forward") Boolean forward); }### Answer:
@Test public void testDeleteConnector() throws Throwable { final Capture<Callback<Herder.Created<ConnectorInfo>>> cb = Capture.newInstance(); herder.deleteConnectorConfig(EasyMock.eq(CONNECTOR_NAME), EasyMock.capture(cb)); expectAndCallbackResult(cb, null); PowerMock.replayAll(); connectorsResource.destroyConnector(CONNECTOR_NAME, FORWARD); PowerMock.verifyAll(); }
@Test public void testDeleteConnectorNotLeader() throws Throwable { final Capture<Callback<Herder.Created<ConnectorInfo>>> cb = Capture.newInstance(); herder.deleteConnectorConfig(EasyMock.eq(CONNECTOR_NAME), EasyMock.capture(cb)); expectAndCallbackNotLeaderException(cb); EasyMock.expect(RestServer.httpRequest("http: .andReturn(new RestServer.HttpResponse<>(204, new HashMap<String, List<String>>(), null)); PowerMock.replayAll(); connectorsResource.destroyConnector(CONNECTOR_NAME, FORWARD); PowerMock.verifyAll(); }
@Test(expected = NotFoundException.class) public void testDeleteConnectorNotFound() throws Throwable { final Capture<Callback<Herder.Created<ConnectorInfo>>> cb = Capture.newInstance(); herder.deleteConnectorConfig(EasyMock.eq(CONNECTOR_NAME), EasyMock.capture(cb)); expectAndCallbackException(cb, new NotFoundException("not found")); PowerMock.replayAll(); connectorsResource.destroyConnector(CONNECTOR_NAME, FORWARD); PowerMock.verifyAll(); } |
### Question:
RecordQueue { public int addRawRecords(Iterable<ConsumerRecord<byte[], byte[]>> rawRecords) { for (ConsumerRecord<byte[], byte[]> rawRecord : rawRecords) { ConsumerRecord<Object, Object> record = recordDeserializer.deserialize(rawRecord); long timestamp = timestampExtractor.extract(record, timeTracker.get()); log.trace("Source node {} extracted timestamp {} for record {}", source.name(), timestamp, record); if (timestamp < 0) { continue; } StampedRecord stampedRecord = new StampedRecord(record, timestamp); fifoQueue.addLast(stampedRecord); timeTracker.addElement(stampedRecord); } long timestamp = timeTracker.get(); if (timestamp > partitionTime) partitionTime = timestamp; return size(); } RecordQueue(final TopicPartition partition,
final SourceNode source,
final TimestampExtractor timestampExtractor); SourceNode source(); TopicPartition partition(); int addRawRecords(Iterable<ConsumerRecord<byte[], byte[]>> rawRecords); StampedRecord poll(); int size(); boolean isEmpty(); long timestamp(); void clear(); }### Answer:
@Test(expected = StreamsException.class) public void shouldThrowStreamsExceptionWhenKeyDeserializationFails() throws Exception { final byte[] key = Serdes.Long().serializer().serialize("foo", 1L); final List<ConsumerRecord<byte[], byte[]>> records = Collections.singletonList( new ConsumerRecord<>("topic", 1, 1, 0L, TimestampType.CREATE_TIME, 0L, 0, 0, key, recordValue)); queue.addRawRecords(records); }
@Test(expected = StreamsException.class) public void shouldThrowStreamsExceptionWhenValueDeserializationFails() throws Exception { final byte[] value = Serdes.Long().serializer().serialize("foo", 1L); final List<ConsumerRecord<byte[], byte[]>> records = Collections.singletonList( new ConsumerRecord<>("topic", 1, 1, 0L, TimestampType.CREATE_TIME, 0L, 0, 0, recordKey, value)); queue.addRawRecords(records); }
@Test(expected = StreamsException.class) public void shouldThrowOnNegativeTimestamp() { final List<ConsumerRecord<byte[], byte[]>> records = Collections.singletonList( new ConsumerRecord<>("topic", 1, 1, -1L, TimestampType.CREATE_TIME, 0L, 0, 0, recordKey, recordValue)); final RecordQueue queue = new RecordQueue(new TopicPartition(topics[0], 1), new MockSourceNode<>(topics, intDeserializer, intDeserializer), new FailOnInvalidTimestamp()); queue.addRawRecords(records); } |
### Question:
ProcessorNode { public void init(ProcessorContext context) { this.context = context; try { nodeMetrics = new NodeMetrics(context.metrics(), name, "task." + context.taskId()); nodeMetrics.metrics.measureLatencyNs(time, initDelegate, nodeMetrics.nodeCreationSensor); } catch (Exception e) { throw new StreamsException(String.format("failed to initialize processor %s", name), e); } } ProcessorNode(String name); ProcessorNode(String name, Processor<K, V> processor, Set<String> stateStores); final String name(); final Processor<K, V> processor(); final List<ProcessorNode<?, ?>> children(); void addChild(ProcessorNode<?, ?> child); void init(ProcessorContext context); void close(); void process(final K key, final V value); void punctuate(long timestamp); @Override String toString(); String toString(String indent); final Set<String> stateStores; }### Answer:
@SuppressWarnings("unchecked") @Test (expected = StreamsException.class) public void shouldThrowStreamsExceptionIfExceptionCaughtDuringInit() throws Exception { final ProcessorNode node = new ProcessorNode("name", new ExceptionalProcessor(), Collections.emptySet()); node.init(null); } |
### Question:
ProcessorNode { public void close() { try { nodeMetrics.metrics.measureLatencyNs(time, closeDelegate, nodeMetrics.nodeDestructionSensor); nodeMetrics.removeAllSensors(); } catch (Exception e) { throw new StreamsException(String.format("failed to close processor %s", name), e); } } ProcessorNode(String name); ProcessorNode(String name, Processor<K, V> processor, Set<String> stateStores); final String name(); final Processor<K, V> processor(); final List<ProcessorNode<?, ?>> children(); void addChild(ProcessorNode<?, ?> child); void init(ProcessorContext context); void close(); void process(final K key, final V value); void punctuate(long timestamp); @Override String toString(); String toString(String indent); final Set<String> stateStores; }### Answer:
@SuppressWarnings("unchecked") @Test (expected = StreamsException.class) public void shouldThrowStreamsExceptionIfExceptionCaughtDuringClose() throws Exception { final ProcessorNode node = new ProcessorNode("name", new ExceptionalProcessor(), Collections.emptySet()); node.close(); } |
### Question:
SourceNode extends ProcessorNode<K, V> { K deserializeKey(String topic, Headers headers, byte[] data) { return keyDeserializer.deserialize(topic, headers, data); } SourceNode(String name, List<String> topics, TimestampExtractor timestampExtractor, Deserializer<K> keyDeserializer, Deserializer<V> valDeserializer); SourceNode(String name, List<String> topics, Deserializer<K> keyDeserializer, Deserializer<V> valDeserializer); @SuppressWarnings("unchecked") @Override void init(ProcessorContext context); @Override void process(final K key, final V value); @Override String toString(); String toString(String indent); TimestampExtractor getTimestampExtractor(); }### Answer:
@Test public void shouldProvideTopicHeadersAndDataToKeyDeserializer() { final SourceNode<String, String> sourceNode = new MockSourceNode<>(new String[]{""}, new TheExtendedDeserializer(), new TheExtendedDeserializer()); final RecordHeaders headers = new RecordHeaders(); final String deserializeKey = sourceNode.deserializeKey("topic", headers, "data".getBytes(StandardCharsets.UTF_8)); assertThat(deserializeKey, is("topic" + headers + "data")); } |
### Question:
SourceNode extends ProcessorNode<K, V> { V deserializeValue(String topic, Headers headers, byte[] data) { return valDeserializer.deserialize(topic, headers, data); } SourceNode(String name, List<String> topics, TimestampExtractor timestampExtractor, Deserializer<K> keyDeserializer, Deserializer<V> valDeserializer); SourceNode(String name, List<String> topics, Deserializer<K> keyDeserializer, Deserializer<V> valDeserializer); @SuppressWarnings("unchecked") @Override void init(ProcessorContext context); @Override void process(final K key, final V value); @Override String toString(); String toString(String indent); TimestampExtractor getTimestampExtractor(); }### Answer:
@Test public void shouldProvideTopicHeadersAndDataToValueDeserializer() { final SourceNode<String, String> sourceNode = new MockSourceNode<>(new String[]{""}, new TheExtendedDeserializer(), new TheExtendedDeserializer()); final RecordHeaders headers = new RecordHeaders(); final String deserializedValue = sourceNode.deserializeValue("topic", headers, "data".getBytes(StandardCharsets.UTF_8)); assertThat(deserializedValue, is("topic" + headers + "data")); } |
### Question:
ProcessorStateManager implements StateManager { @Override public StateStore getStore(final String name) { return stores.get(name); } ProcessorStateManager(final TaskId taskId,
final Collection<TopicPartition> sources,
final boolean isStandby,
final StateDirectory stateDirectory,
final Map<String, String> storeToChangelogTopic,
final ChangelogReader changelogReader,
final boolean eosEnabled); static String storeChangelogTopic(final String applicationId, final String storeName); @Override File baseDir(); @Override void register(final StateStore store,
final boolean loggingEnabled,
final StateRestoreCallback stateRestoreCallback); @Override Map<TopicPartition, Long> checkpointed(); @Override StateStore getStore(final String name); @Override void flush(); @Override void close(final Map<TopicPartition, Long> ackedOffsets); @Override void checkpoint(final Map<TopicPartition, Long> ackedOffsets); @Override StateStore getGlobalStore(final String name); static final String STATE_CHANGELOG_TOPIC_SUFFIX; }### Answer:
@Test public void testGetStore() throws IOException { final MockStateStoreSupplier.MockStateStore mockStateStore = new MockStateStoreSupplier.MockStateStore(nonPersistentStoreName, false); final ProcessorStateManager stateMgr = new ProcessorStateManager( new TaskId(0, 1), noPartitions, false, stateDirectory, Collections.<String, String>emptyMap(), changelogReader, false); try { stateMgr.register(mockStateStore, true, mockStateStore.stateRestoreCallback); assertNull(stateMgr.getStore("noSuchStore")); assertEquals(mockStateStore, stateMgr.getStore(nonPersistentStoreName)); } finally { stateMgr.close(Collections.<TopicPartition, Long>emptyMap()); } } |
### Question:
ProcessorStateManager implements StateManager { @Override public void close(final Map<TopicPartition, Long> ackedOffsets) throws ProcessorStateException { RuntimeException firstException = null; try { if (!stores.isEmpty()) { log.debug("{} Closing its state manager and all the registered state stores", logPrefix); for (final Map.Entry<String, StateStore> entry : stores.entrySet()) { log.debug("{} Closing storage engine {}", logPrefix, entry.getKey()); try { entry.getValue().close(); } catch (final Exception e) { if (firstException == null) { firstException = new ProcessorStateException(String.format("%s Failed to close state store %s", logPrefix, entry.getKey()), e); } log.error("{} Failed to close state store {}: ", logPrefix, entry.getKey(), e); } } if (ackedOffsets != null) { checkpoint(ackedOffsets); } } } finally { try { stateDirectory.unlock(taskId); } catch (final IOException e) { if (firstException == null) { firstException = new ProcessorStateException(String.format("%s Failed to release state dir lock", logPrefix), e); } log.error("{} Failed to release state dir lock: ", logPrefix, e); } } if (firstException != null) { throw firstException; } } ProcessorStateManager(final TaskId taskId,
final Collection<TopicPartition> sources,
final boolean isStandby,
final StateDirectory stateDirectory,
final Map<String, String> storeToChangelogTopic,
final ChangelogReader changelogReader,
final boolean eosEnabled); static String storeChangelogTopic(final String applicationId, final String storeName); @Override File baseDir(); @Override void register(final StateStore store,
final boolean loggingEnabled,
final StateRestoreCallback stateRestoreCallback); @Override Map<TopicPartition, Long> checkpointed(); @Override StateStore getStore(final String name); @Override void flush(); @Override void close(final Map<TopicPartition, Long> ackedOffsets); @Override void checkpoint(final Map<TopicPartition, Long> ackedOffsets); @Override StateStore getGlobalStore(final String name); static final String STATE_CHANGELOG_TOPIC_SUFFIX; }### Answer:
@Test public void shouldThrowLockExceptionIfFailedToLockStateDirectory() throws Exception { final File taskDirectory = stateDirectory.directoryForTask(taskId); final FileChannel channel = FileChannel.open(new File(taskDirectory, StateDirectory.LOCK_FILE_NAME).toPath(), StandardOpenOption.CREATE, StandardOpenOption.WRITE); final FileLock lock = channel.lock(); try { new ProcessorStateManager( taskId, noPartitions, false, stateDirectory, Collections.<String, String>emptyMap(), changelogReader, false); fail("Should have thrown LockException"); } catch (final LockException e) { } finally { lock.release(); channel.close(); } }
@Test public void shouldDeleteCheckpointFileOnCreationIfEosEnabled() throws Exception { checkpoint.write(Collections.<TopicPartition, Long>emptyMap()); assertTrue(checkpointFile.exists()); ProcessorStateManager stateManager = null; try { stateManager = new ProcessorStateManager( taskId, noPartitions, false, stateDirectory, Collections.<String, String>emptyMap(), changelogReader, true); assertFalse(checkpointFile.exists()); } finally { if (stateManager != null) { stateManager.close(null); } } } |
### Question:
ProcessorStateManager implements StateManager { @Override public void register(final StateStore store, final boolean loggingEnabled, final StateRestoreCallback stateRestoreCallback) { log.debug("{} Registering state store {} to its state manager", logPrefix, store.name()); if (store.name().equals(CHECKPOINT_FILE_NAME)) { throw new IllegalArgumentException(String.format("%s Illegal store name: %s", logPrefix, CHECKPOINT_FILE_NAME)); } if (stores.containsKey(store.name())) { throw new IllegalArgumentException(String.format("%s Store %s has already been registered.", logPrefix, store.name())); } final String topic = storeToChangelogTopic.get(store.name()); if (topic == null) { stores.put(store.name(), store); return; } final TopicPartition storePartition = new TopicPartition(topic, getPartition(topic)); changelogReader.validatePartitionExists(storePartition, store.name()); if (isStandby) { if (store.persistent()) { log.trace("{} Preparing standby replica of persistent state store {} with changelog topic {}", logPrefix, store.name(), topic); restoreCallbacks.put(topic, stateRestoreCallback); } } else { log.trace("{} Restoring state store {} from changelog topic {}", logPrefix, store.name(), topic); final StateRestorer restorer = new StateRestorer(storePartition, stateRestoreCallback, checkpointedOffsets.get(storePartition), offsetLimit(storePartition), store.persistent()); changelogReader.register(restorer); } stores.put(store.name(), store); } ProcessorStateManager(final TaskId taskId,
final Collection<TopicPartition> sources,
final boolean isStandby,
final StateDirectory stateDirectory,
final Map<String, String> storeToChangelogTopic,
final ChangelogReader changelogReader,
final boolean eosEnabled); static String storeChangelogTopic(final String applicationId, final String storeName); @Override File baseDir(); @Override void register(final StateStore store,
final boolean loggingEnabled,
final StateRestoreCallback stateRestoreCallback); @Override Map<TopicPartition, Long> checkpointed(); @Override StateStore getStore(final String name); @Override void flush(); @Override void close(final Map<TopicPartition, Long> ackedOffsets); @Override void checkpoint(final Map<TopicPartition, Long> ackedOffsets); @Override StateStore getGlobalStore(final String name); static final String STATE_CHANGELOG_TOPIC_SUFFIX; }### Answer:
@Test public void shouldThrowIllegalArgumentExceptionIfStoreNameIsSameAsCheckpointFileName() throws Exception { final ProcessorStateManager stateManager = new ProcessorStateManager( taskId, noPartitions, false, stateDirectory, Collections.<String, String>emptyMap(), changelogReader, false); try { stateManager.register(new MockStateStoreSupplier.MockStateStore(ProcessorStateManager.CHECKPOINT_FILE_NAME, true), true, null); fail("should have thrown illegal argument exception when store name same as checkpoint file"); } catch (final IllegalArgumentException e) { } }
@Test public void shouldThrowIllegalArgumentExceptionOnRegisterWhenStoreHasAlreadyBeenRegistered() throws Exception { final ProcessorStateManager stateManager = new ProcessorStateManager( taskId, noPartitions, false, stateDirectory, Collections.<String, String>emptyMap(), changelogReader, false); stateManager.register(mockStateStore, false, null); try { stateManager.register(mockStateStore, false, null); fail("should have thrown illegal argument exception when store with same name already registered"); } catch (final IllegalArgumentException e) { } } |
### Question:
MinTimestampTracker implements TimestampTracker<E> { public long get() { Stamped<E> stamped = ascendingSubsequence.peekFirst(); if (stamped == null) return lastKnownTime; else return stamped.timestamp; } void addElement(final Stamped<E> elem); void removeElement(final Stamped<E> elem); int size(); long get(); }### Answer:
@Test public void shouldReturnNotKnownTimestampWhenNoRecordsEverAdded() throws Exception { assertThat(tracker.get(), equalTo(TimestampTracker.NOT_KNOWN)); } |
### Question:
MinTimestampTracker implements TimestampTracker<E> { public void removeElement(final Stamped<E> elem) { if (elem == null) { return; } if (ascendingSubsequence.peekFirst() == elem) { ascendingSubsequence.removeFirst(); } if (ascendingSubsequence.isEmpty()) { lastKnownTime = elem.timestamp; } } void addElement(final Stamped<E> elem); void removeElement(final Stamped<E> elem); int size(); long get(); }### Answer:
@Test public void shouldIgnoreNullRecordOnRemove() throws Exception { tracker.removeElement(null); } |
### Question:
MinTimestampTracker implements TimestampTracker<E> { public void addElement(final Stamped<E> elem) { if (elem == null) throw new NullPointerException(); Stamped<E> maxElem = ascendingSubsequence.peekLast(); while (maxElem != null && maxElem.timestamp >= elem.timestamp) { ascendingSubsequence.removeLast(); maxElem = ascendingSubsequence.peekLast(); } ascendingSubsequence.offerLast(elem); } void addElement(final Stamped<E> elem); void removeElement(final Stamped<E> elem); int size(); long get(); }### Answer:
@Test(expected = NullPointerException.class) public void shouldThrowNullPointerExceptionWhenTryingToAddNullElement() throws Exception { tracker.addElement(null); } |
### Question:
SourceNodeRecordDeserializer implements RecordDeserializer { @Override public ConsumerRecord<Object, Object> deserialize(final ConsumerRecord<byte[], byte[]> rawRecord) { final Object key; try { key = sourceNode.deserializeKey(rawRecord.topic(), rawRecord.headers(), rawRecord.key()); } catch (Exception e) { throw new StreamsException(format("Failed to deserialize key for record. topic=%s, partition=%d, offset=%d", rawRecord.topic(), rawRecord.partition(), rawRecord.offset()), e); } final Object value; try { value = sourceNode.deserializeValue(rawRecord.topic(), rawRecord.headers(), rawRecord.value()); } catch (Exception e) { throw new StreamsException(format("Failed to deserialize value for record. topic=%s, partition=%d, offset=%d", rawRecord.topic(), rawRecord.partition(), rawRecord.offset()), e); } return new ConsumerRecord<>(rawRecord.topic(), rawRecord.partition(), rawRecord.offset(), rawRecord.timestamp(), TimestampType.CREATE_TIME, rawRecord.checksum(), rawRecord.serializedKeySize(), rawRecord.serializedValueSize(), key, value); } SourceNodeRecordDeserializer(final SourceNode sourceNode); @Override ConsumerRecord<Object, Object> deserialize(final ConsumerRecord<byte[], byte[]> rawRecord); }### Answer:
@Test(expected = StreamsException.class) public void shouldThrowStreamsExceptionIfKeyFailsToDeserialize() throws Exception { final SourceNodeRecordDeserializer recordDeserializer = new SourceNodeRecordDeserializer( new TheSourceNode(true, false)); recordDeserializer.deserialize(rawRecord); }
@Test(expected = StreamsException.class) public void shouldThrowStreamsExceptionIfKeyValueFailsToDeserialize() throws Exception { final SourceNodeRecordDeserializer recordDeserializer = new SourceNodeRecordDeserializer( new TheSourceNode(false, true)); recordDeserializer.deserialize(rawRecord); }
@Test public void shouldReturnNewConsumerRecordWithDeserializedValueWhenNoExceptions() throws Exception { final SourceNodeRecordDeserializer recordDeserializer = new SourceNodeRecordDeserializer( new TheSourceNode(false, false, "key", "value")); final ConsumerRecord<Object, Object> record = recordDeserializer.deserialize(rawRecord); assertEquals(rawRecord.topic(), record.topic()); assertEquals(rawRecord.partition(), record.partition()); assertEquals(rawRecord.offset(), record.offset()); assertEquals(rawRecord.checksum(), record.checksum()); assertEquals("key", record.key()); assertEquals("value", record.value()); assertEquals(rawRecord.timestamp(), record.timestamp()); assertEquals(TimestampType.CREATE_TIME, record.timestampType()); } |
### Question:
AssignmentInfo { public static AssignmentInfo decode(ByteBuffer data) { data.rewind(); DataInputStream in = new DataInputStream(new ByteBufferInputStream(data)); try { int version = in.readInt(); if (version < 0 || version > CURRENT_VERSION) { TaskAssignmentException ex = new TaskAssignmentException("Unknown assignment data version: " + version); log.error(ex.getMessage(), ex); throw ex; } int count = in.readInt(); List<TaskId> activeTasks = new ArrayList<>(count); for (int i = 0; i < count; i++) { activeTasks.add(TaskId.readFrom(in)); } count = in.readInt(); Map<TaskId, Set<TopicPartition>> standbyTasks = new HashMap<>(count); for (int i = 0; i < count; i++) { TaskId id = TaskId.readFrom(in); standbyTasks.put(id, readTopicPartitions(in)); } Map<HostInfo, Set<TopicPartition>> hostStateToTopicPartitions = new HashMap<>(); if (version == CURRENT_VERSION) { int numEntries = in.readInt(); for (int i = 0; i < numEntries; i++) { HostInfo hostInfo = new HostInfo(in.readUTF(), in.readInt()); hostStateToTopicPartitions.put(hostInfo, readTopicPartitions(in)); } } return new AssignmentInfo(activeTasks, standbyTasks, hostStateToTopicPartitions); } catch (IOException ex) { throw new TaskAssignmentException("Failed to decode AssignmentInfo", ex); } } AssignmentInfo(List<TaskId> activeTasks, Map<TaskId, Set<TopicPartition>> standbyTasks,
Map<HostInfo, Set<TopicPartition>> hostState); protected AssignmentInfo(int version, List<TaskId> activeTasks, Map<TaskId, Set<TopicPartition>> standbyTasks,
Map<HostInfo, Set<TopicPartition>> hostState); ByteBuffer encode(); static AssignmentInfo decode(ByteBuffer data); @Override int hashCode(); @Override boolean equals(Object o); @Override String toString(); final int version; final List<TaskId> activeTasks; final Map<TaskId, Set<TopicPartition>> standbyTasks; final Map<HostInfo, Set<TopicPartition>> partitionsByHost; }### Answer:
@Test public void shouldDecodePreviousVersion() throws Exception { List<TaskId> activeTasks = Arrays.asList(new TaskId(0, 0), new TaskId(0, 0), new TaskId(0, 1), new TaskId(1, 0)); Map<TaskId, Set<TopicPartition>> standbyTasks = new HashMap<>(); standbyTasks.put(new TaskId(1, 1), Utils.mkSet(new TopicPartition("t1", 1), new TopicPartition("t2", 1))); standbyTasks.put(new TaskId(2, 0), Utils.mkSet(new TopicPartition("t3", 0), new TopicPartition("t3", 0))); final AssignmentInfo oldVersion = new AssignmentInfo(1, activeTasks, standbyTasks, null); final AssignmentInfo decoded = AssignmentInfo.decode(encodeV1(oldVersion)); assertEquals(oldVersion.activeTasks, decoded.activeTasks); assertEquals(oldVersion.standbyTasks, decoded.standbyTasks); assertEquals(0, decoded.partitionsByHost.size()); assertEquals(2, decoded.version); } |
### Question:
ConnectorsResource { @GET @Path("/{connector}") public ConnectorInfo getConnector(final @PathParam("connector") String connector, final @QueryParam("forward") Boolean forward) throws Throwable { FutureCallback<ConnectorInfo> cb = new FutureCallback<>(); herder.connectorInfo(connector, cb); return completeOrForwardRequest(cb, "/connectors/" + connector, "GET", null, forward); } ConnectorsResource(Herder herder); @GET @Path("/") Collection<String> listConnectors(final @QueryParam("forward") Boolean forward); @POST @Path("/") Response createConnector(final @QueryParam("forward") Boolean forward,
final CreateConnectorRequest createRequest); @GET @Path("/{connector}") ConnectorInfo getConnector(final @PathParam("connector") String connector,
final @QueryParam("forward") Boolean forward); @GET @Path("/{connector}/config") Map<String, String> getConnectorConfig(final @PathParam("connector") String connector,
final @QueryParam("forward") Boolean forward); @GET @Path("/{connector}/status") ConnectorStateInfo getConnectorStatus(final @PathParam("connector") String connector); @PUT @Path("/{connector}/config") Response putConnectorConfig(final @PathParam("connector") String connector,
final @QueryParam("forward") Boolean forward,
final Map<String, String> connectorConfig); @POST @Path("/{connector}/restart") void restartConnector(final @PathParam("connector") String connector,
final @QueryParam("forward") Boolean forward); @PUT @Path("/{connector}/pause") Response pauseConnector(@PathParam("connector") String connector); @PUT @Path("/{connector}/resume") Response resumeConnector(@PathParam("connector") String connector); @GET @Path("/{connector}/tasks") List<TaskInfo> getTaskConfigs(final @PathParam("connector") String connector,
final @QueryParam("forward") Boolean forward); @POST @Path("/{connector}/tasks") void putTaskConfigs(final @PathParam("connector") String connector,
final @QueryParam("forward") Boolean forward,
final List<Map<String, String>> taskConfigs); @GET @Path("/{connector}/tasks/{task}/status") ConnectorStateInfo.TaskState getTaskStatus(final @PathParam("connector") String connector,
final @PathParam("task") Integer task); @POST @Path("/{connector}/tasks/{task}/restart") void restartTask(final @PathParam("connector") String connector,
final @PathParam("task") Integer task,
final @QueryParam("forward") Boolean forward); @DELETE @Path("/{connector}") void destroyConnector(final @PathParam("connector") String connector,
final @QueryParam("forward") Boolean forward); }### Answer:
@Test public void testGetConnector() throws Throwable { final Capture<Callback<ConnectorInfo>> cb = Capture.newInstance(); herder.connectorInfo(EasyMock.eq(CONNECTOR_NAME), EasyMock.capture(cb)); expectAndCallbackResult(cb, new ConnectorInfo(CONNECTOR_NAME, CONNECTOR_CONFIG, CONNECTOR_TASK_NAMES)); PowerMock.replayAll(); ConnectorInfo connInfo = connectorsResource.getConnector(CONNECTOR_NAME, FORWARD); assertEquals(new ConnectorInfo(CONNECTOR_NAME, CONNECTOR_CONFIG, CONNECTOR_TASK_NAMES), connInfo); PowerMock.verifyAll(); } |
### Question:
CarManufacturer { public Car manufactureCar(Specification spec) { Car car = carFactory.createCar(spec); entityManager.merge(car); return car; } Car manufactureCar(Specification spec); }### Answer:
@Test public void test() { Specification spec = new Specification(); Car car = new Car(spec); when(entityManager.merge(any())).then(a -> a.getArgument(0)); when(carFactory.createCar(any())).thenReturn(car); assertThat(testObject.manufactureCar(spec)).isEqualTo(car); verify(carFactory).createCar(spec); verify(entityManager).merge(car); }
@Test public void test() { Specification spec = new Specification(); Car car = new Car(spec); when(testObject.entityManager.merge(any())).then(a -> a.getArgument(0)); when(testObject.carFactory.createCar(any())).thenReturn(car); assertThat(testObject.manufactureCar(spec)).isEqualTo(car); verify(testObject.carFactory).createCar(spec); verify(testObject.entityManager).merge(car); } |
### Question:
Types { public static boolean isAssignable(Class<?> lhsType, Class<?> rhsType) { if (lhsType.isAssignableFrom(rhsType)) { return true; } return lhsType.isPrimitive() ? lhsType.equals(Primitives.unwrap(rhsType)) : lhsType.isAssignableFrom(Primitives.wrap(rhsType)); } private Types(); static boolean isAssignable(Class<?> lhsType, Class<?> rhsType); static boolean equals(Class<?> lhsType, Class<?> rhsType); }### Answer:
@Test public void testIsAssignable() throws Exception { assertThat(Types.isAssignable(int.class, Integer.class), is(true)); assertThat(Types.isAssignable(Integer.class, Integer.class), is(true)); assertThat(Types.isAssignable(Integer.class, int.class), is(true)); assertThat(Types.isAssignable(int.class, int.class), is(true)); assertThat(Types.isAssignable(int.class, long.class), is(false)); assertThat(Types.isAssignable(Integer.class, Long.class), is(false)); assertThat(Types.isAssignable(A.class, B.class), is(true)); assertThat(Types.isAssignable(A.class, A.class), is(true)); assertThat(Types.isAssignable(B.class, B.class), is(true)); assertThat(Types.isAssignable(B.class, A.class), is(false)); } |
### Question:
Parser implements ParserTreeConstants, ParserConstants { final public void IntegerLiteral() throws ParseException { ASTIntegerLiteral jjtn000 = new ASTIntegerLiteral(JJTINTEGERLITERAL); boolean jjtc000 = true; jjtree.openNodeScope(jjtn000); jjtn000.jjtSetFirstToken(getToken(1));Token t; try { t = jj_consume_token(INTEGER_LITERAL); jjtree.closeNodeScope(jjtn000, true); jjtc000 = false; jjtn000.jjtSetLastToken(getToken(0)); jjtn000.init(t.image); } finally { if (jjtc000) { jjtree.closeNodeScope(jjtn000, true); jjtn000.jjtSetLastToken(getToken(0)); } } } Parser(String s); Parser(java.io.InputStream stream); Parser(java.io.InputStream stream, String encoding); Parser(Reader stream); Parser(ParserTokenManager tm); final ASTRootNode parse(); final void DML(); final void Insert(); final void Delete(); final void Update(); final void Select(); final void Replace(); final void Merge(); final void Truncate(); final void Statement(); final void JDBCParameter(); final void JDBCIterableParameter(); final void GlobalTable(); final void JoinParameter(); final void QuoteText(); final void Text(); final void Blank(); final void IfStatement(); final void ElseStatement(); final void ElseIfStatement(); final void Expression(); final void ConditionalOrExpression(); final void ConditionalAndExpression(); final void RelationalExpression(); final void UnaryExpression(); final void PrimaryExpression(); final void ExpressionParameter(); final void IntegerLiteral(); final void StringLiteral(); final void True(); final void False(); final void Null(); void ReInit(java.io.InputStream stream); void ReInit(java.io.InputStream stream, String encoding); void ReInit(Reader stream); void ReInit(ParserTokenManager tm); final Token getNextToken(); final Token getToken(int index); ParseException generateParseException(); final void enable_tracing(); final void disable_tracing(); public ParserTokenManager token_source; public Token token; public Token jj_nt; }### Answer:
@Test public void testIntegerLiteral() throws Exception { String sql = "select #if (:1 > 9223372036854775800) ok #end"; ASTRootNode n = new Parser(sql).parse().init(); ParameterContext ctx = getParameterContext(Lists.newArrayList((Type) Integer.class)); n.checkAndBind(ctx); InvocationContext context = DefaultInvocationContext.create(); context.addParameter("1", Long.MAX_VALUE); n.render(context); BoundSql boundSql = context.getBoundSql(); assertThat(boundSql.getSql(), Matchers.equalTo("select ok ")); } |
### Question:
Soundex implements StringEncoder { public int difference(final String s1, final String s2) throws EncoderException { return SoundexUtils.difference(this, s1, s2); } Soundex(); Soundex(final char[] mapping); Soundex(final String mapping); int difference(final String s1, final String s2); @Override Object encode(final Object obj); @Override String encode(final String str); @Deprecated int getMaxLength(); @Deprecated void setMaxLength(final int maxLength); String soundex(String str); static final String US_ENGLISH_MAPPING_STRING; static final Soundex US_ENGLISH; }### Answer:
@Test public void testDifference() throws EncoderException { Assert.assertEquals(0, this.getStringEncoder().difference(null, null)); Assert.assertEquals(0, this.getStringEncoder().difference("", "")); Assert.assertEquals(0, this.getStringEncoder().difference(" ", " ")); Assert.assertEquals(4, this.getStringEncoder().difference("Smith", "Smythe")); Assert.assertEquals(2, this.getStringEncoder().difference("Ann", "Andrew")); Assert.assertEquals(1, this.getStringEncoder().difference("Margaret", "Andrew")); Assert.assertEquals(0, this.getStringEncoder().difference("Janet", "Margaret")); Assert.assertEquals(4, this.getStringEncoder().difference("Green", "Greene")); Assert.assertEquals(0, this.getStringEncoder().difference("Blotchet-Halls", "Greene")); Assert.assertEquals(4, this.getStringEncoder().difference("Smith", "Smythe")); Assert.assertEquals(4, this.getStringEncoder().difference("Smithers", "Smythers")); Assert.assertEquals(2, this.getStringEncoder().difference("Anothers", "Brothers")); } |
### Question:
Parser implements ParserTreeConstants, ParserConstants { final public void Replace() throws ParseException { ASTReplace jjtn000 = new ASTReplace(JJTREPLACE); boolean jjtc000 = true; jjtree.openNodeScope(jjtn000); jjtn000.jjtSetFirstToken(getToken(1));Token t; try { t = jj_consume_token(REPLACE); jjtree.closeNodeScope(jjtn000, true); jjtc000 = false; jjtn000.jjtSetLastToken(getToken(0)); jjtn000.setValue(t.image); } finally { if (jjtc000) { jjtree.closeNodeScope(jjtn000, true); jjtn000.jjtSetLastToken(getToken(0)); } } } Parser(String s); Parser(java.io.InputStream stream); Parser(java.io.InputStream stream, String encoding); Parser(Reader stream); Parser(ParserTokenManager tm); final ASTRootNode parse(); final void DML(); final void Insert(); final void Delete(); final void Update(); final void Select(); final void Replace(); final void Merge(); final void Truncate(); final void Statement(); final void JDBCParameter(); final void JDBCIterableParameter(); final void GlobalTable(); final void JoinParameter(); final void QuoteText(); final void Text(); final void Blank(); final void IfStatement(); final void ElseStatement(); final void ElseIfStatement(); final void Expression(); final void ConditionalOrExpression(); final void ConditionalAndExpression(); final void RelationalExpression(); final void UnaryExpression(); final void PrimaryExpression(); final void ExpressionParameter(); final void IntegerLiteral(); final void StringLiteral(); final void True(); final void False(); final void Null(); void ReInit(java.io.InputStream stream); void ReInit(java.io.InputStream stream, String encoding); void ReInit(Reader stream); void ReInit(ParserTokenManager tm); final Token getNextToken(); final Token getToken(int index); ParseException generateParseException(); final void enable_tracing(); final void disable_tracing(); public ParserTokenManager token_source; public Token token; public Token jj_nt; }### Answer:
@Test public void testReplace() throws Exception { String sql = "replace xxx into replace xxx"; ASTRootNode n = new Parser(sql).parse().init(); List<Type> types = Lists.newArrayList(); ParameterContext ctx = getParameterContext(types); n.checkAndBind(ctx); InvocationContext context = DefaultInvocationContext.create(); n.render(context); BoundSql boundSql = context.getBoundSql(); assertThat(boundSql.getSql(), Matchers.equalTo("replace xxx into replace xxx")); assertThat(n.getSQLType(), is(SQLType.REPLACE)); } |
### Question:
Soundex implements StringEncoder { public Soundex() { this.soundexMapping = US_ENGLISH_MAPPING; } Soundex(); Soundex(final char[] mapping); Soundex(final String mapping); int difference(final String s1, final String s2); @Override Object encode(final Object obj); @Override String encode(final String str); @Deprecated int getMaxLength(); @Deprecated void setMaxLength(final int maxLength); String soundex(String str); static final String US_ENGLISH_MAPPING_STRING; static final Soundex US_ENGLISH; }### Answer:
@Test public void testNewInstance() { Assert.assertEquals("W452", new Soundex().soundex("Williams")); }
@Test public void testNewInstance2() { Assert.assertEquals("W452", new Soundex(Soundex.US_ENGLISH_MAPPING_STRING.toCharArray()).soundex("Williams")); }
@Test public void testNewInstance3() { Assert.assertEquals("W452", new Soundex(Soundex.US_ENGLISH_MAPPING_STRING).soundex("Williams")); }
@Test public void testUsEnglishStatic() { Assert.assertEquals("W452", Soundex.US_ENGLISH.soundex("Williams")); } |
### Question:
Parser implements ParserTreeConstants, ParserConstants { final public void Merge() throws ParseException { ASTMerge jjtn000 = new ASTMerge(JJTMERGE); boolean jjtc000 = true; jjtree.openNodeScope(jjtn000); jjtn000.jjtSetFirstToken(getToken(1));Token t; try { t = jj_consume_token(MERGE); jjtree.closeNodeScope(jjtn000, true); jjtc000 = false; jjtn000.jjtSetLastToken(getToken(0)); jjtn000.setValue(t.image); } finally { if (jjtc000) { jjtree.closeNodeScope(jjtn000, true); jjtn000.jjtSetLastToken(getToken(0)); } } } Parser(String s); Parser(java.io.InputStream stream); Parser(java.io.InputStream stream, String encoding); Parser(Reader stream); Parser(ParserTokenManager tm); final ASTRootNode parse(); final void DML(); final void Insert(); final void Delete(); final void Update(); final void Select(); final void Replace(); final void Merge(); final void Truncate(); final void Statement(); final void JDBCParameter(); final void JDBCIterableParameter(); final void GlobalTable(); final void JoinParameter(); final void QuoteText(); final void Text(); final void Blank(); final void IfStatement(); final void ElseStatement(); final void ElseIfStatement(); final void Expression(); final void ConditionalOrExpression(); final void ConditionalAndExpression(); final void RelationalExpression(); final void UnaryExpression(); final void PrimaryExpression(); final void ExpressionParameter(); final void IntegerLiteral(); final void StringLiteral(); final void True(); final void False(); final void Null(); void ReInit(java.io.InputStream stream); void ReInit(java.io.InputStream stream, String encoding); void ReInit(Reader stream); void ReInit(ParserTokenManager tm); final Token getNextToken(); final Token getToken(int index); ParseException generateParseException(); final void enable_tracing(); final void disable_tracing(); public ParserTokenManager token_source; public Token token; public Token jj_nt; }### Answer:
@Test public void testMerge() throws Exception { String sql = "merge xxx into merge xxx"; ASTRootNode n = new Parser(sql).parse().init(); List<Type> types = Lists.newArrayList(); ParameterContext ctx = getParameterContext(types); n.checkAndBind(ctx); InvocationContext context = DefaultInvocationContext.create(); n.render(context); BoundSql boundSql = context.getBoundSql(); assertThat(boundSql.getSql(), Matchers.equalTo("merge xxx into merge xxx")); assertThat(n.getSQLType(), is(SQLType.MERGE)); } |
### Question:
TransactionManager { public TransactionManager() { } TransactionManager(); TransactionManager(ConnectionSource connectionSource); void initialize(); T callInTransaction(final Callable<T> callable); T callInTransaction(String tableName, final Callable<T> callable); static T callInTransaction(final ConnectionSource connectionSource, final Callable<T> callable); static T callInTransaction(String tableName, final ConnectionSource connectionSource,
final Callable<T> callable); static T callInTransaction(final DatabaseConnection connection, final DatabaseType databaseType,
final Callable<T> callable); static T callInTransaction(final DatabaseConnection connection, boolean saved,
final DatabaseType databaseType, final Callable<T> callable); void setConnectionSource(ConnectionSource connectionSource); }### Answer:
@Test public void testTransactionManager() throws Exception { ConnectionSource connectionSource = createMock(ConnectionSource.class); DatabaseConnection conn = createMock(DatabaseConnection.class); expect(conn.isAutoCommitSupported()).andReturn(false); Savepoint savePoint = createMock(Savepoint.class); expect(savePoint.getSavepointName()).andReturn("name").anyTimes(); expect(conn.setSavePoint(isA(String.class))).andReturn(savePoint); conn.commit(savePoint); expect(connectionSource.getDatabaseType()).andReturn(databaseType); expect(connectionSource.getReadWriteConnection(null)).andReturn(conn); expect(connectionSource.saveSpecialConnection(conn)).andReturn(true); connectionSource.clearSpecialConnection(conn); connectionSource.releaseConnection(conn); replay(connectionSource, conn, savePoint); TransactionManager tm = new TransactionManager(connectionSource); tm.callInTransaction(new Callable<Void>() { @Override public Void call() { return null; } }); verify(connectionSource, conn, savePoint); } |
### Question:
TransactionManager { public void initialize() { if (connectionSource == null) { throw new IllegalStateException("dataSource was not set on " + getClass().getSimpleName()); } } TransactionManager(); TransactionManager(ConnectionSource connectionSource); void initialize(); T callInTransaction(final Callable<T> callable); T callInTransaction(String tableName, final Callable<T> callable); static T callInTransaction(final ConnectionSource connectionSource, final Callable<T> callable); static T callInTransaction(String tableName, final ConnectionSource connectionSource,
final Callable<T> callable); static T callInTransaction(final DatabaseConnection connection, final DatabaseType databaseType,
final Callable<T> callable); static T callInTransaction(final DatabaseConnection connection, boolean saved,
final DatabaseType databaseType, final Callable<T> callable); void setConnectionSource(ConnectionSource connectionSource); }### Answer:
@Test(expected = IllegalStateException.class) public void testTransactionManagerNoSet() { TransactionManager tm = new TransactionManager(); tm.initialize(); } |
### Question:
TransactionManager { private static void rollBack(DatabaseConnection connection, Savepoint savePoint) throws SQLException { String name = (savePoint == null ? null : savePoint.getSavepointName()); connection.rollback(savePoint); if (name == null) { logger.debug("rolled back savePoint transaction"); } else { logger.debug("rolled back savePoint transaction {}", name); } } TransactionManager(); TransactionManager(ConnectionSource connectionSource); void initialize(); T callInTransaction(final Callable<T> callable); T callInTransaction(String tableName, final Callable<T> callable); static T callInTransaction(final ConnectionSource connectionSource, final Callable<T> callable); static T callInTransaction(String tableName, final ConnectionSource connectionSource,
final Callable<T> callable); static T callInTransaction(final DatabaseConnection connection, final DatabaseType databaseType,
final Callable<T> callable); static T callInTransaction(final DatabaseConnection connection, boolean saved,
final DatabaseType databaseType, final Callable<T> callable); void setConnectionSource(ConnectionSource connectionSource); }### Answer:
@Test public void testRollBack() throws Exception { if (connectionSource == null) { return; } TransactionManager mgr = new TransactionManager(connectionSource); final Dao<Foo, Integer> fooDao = createDao(Foo.class, true); testTransactionManager(mgr, new RuntimeException("What!! I protest!!"), fooDao); } |
### Question:
TransactionManager { public <T> T callInTransaction(final Callable<T> callable) throws SQLException { return callInTransaction(connectionSource, callable); } TransactionManager(); TransactionManager(ConnectionSource connectionSource); void initialize(); T callInTransaction(final Callable<T> callable); T callInTransaction(String tableName, final Callable<T> callable); static T callInTransaction(final ConnectionSource connectionSource, final Callable<T> callable); static T callInTransaction(String tableName, final ConnectionSource connectionSource,
final Callable<T> callable); static T callInTransaction(final DatabaseConnection connection, final DatabaseType databaseType,
final Callable<T> callable); static T callInTransaction(final DatabaseConnection connection, boolean saved,
final DatabaseType databaseType, final Callable<T> callable); void setConnectionSource(ConnectionSource connectionSource); }### Answer:
@Test public void testTransactionWithinTransaction() throws Exception { if (connectionSource == null) { return; } final TransactionManager mgr = new TransactionManager(connectionSource); final Dao<Foo, Integer> dao = createDao(Foo.class, true); mgr.callInTransaction(new Callable<Void>() { @Override public Void call() throws Exception { testTransactionManager(mgr, null, dao); return null; } }); }
@Test public void testTransactionWithinTransactionFails() throws Exception { if (connectionSource == null) { return; } final TransactionManager mgr = new TransactionManager(connectionSource); final Dao<Foo, Integer> dao = createDao(Foo.class, true); try { mgr.callInTransaction(new Callable<Void>() { @Override public Void call() throws Exception { dao.create(new Foo()); mgr.callInTransaction(new Callable<Void>() { @Override public Void call() throws Exception { dao.create(new Foo()); throw new SQLException("Exception ahoy!"); } }); return null; } }); fail("Should have thrown"); } catch (SQLException se) { } List<Foo> results = dao.queryForAll(); assertNotNull(results); assertEquals(0, results.size()); } |
### Question:
SqlExceptionUtil { public static SQLException create(String message, Throwable cause) { SQLException sqlException; if (cause instanceof SQLException) { sqlException = new SQLException(message, ((SQLException) cause).getSQLState()); } else { sqlException = new SQLException(message); } sqlException.initCause(cause); return sqlException; } private SqlExceptionUtil(); static SQLException create(String message, Throwable cause); }### Answer:
@Test public void testException() { Throwable cause = new Throwable(); String msg = "hello"; SQLException e = SqlExceptionUtil.create(msg, cause); assertEquals(msg, e.getMessage()); assertEquals(cause, e.getCause()); }
@Test public void testExceptionWithSQLException() { String sqlReason = "sql exception message"; String sqlState = "sql exception state"; Throwable cause = new SQLException(sqlReason, sqlState); String msg = "hello"; SQLException e = SqlExceptionUtil.create(msg, cause); assertEquals(msg, e.getMessage()); assertEquals(sqlState, e.getSQLState()); assertEquals(cause, e.getCause()); } |
### Question:
BaseDaoEnabled { public int create() throws SQLException { checkForDao(); @SuppressWarnings("unchecked") T t = (T) this; return dao.create(t); } int create(); int refresh(); int update(); int updateId(ID newId); int delete(); String objectToString(); ID extractId(); boolean objectsEqual(T other); void setDao(Dao<T, ID> dao); Dao<T, ID> getDao(); }### Answer:
@Test public void testCreate() throws Exception { Dao<One, Integer> dao = createDao(One.class, true); One one = new One(); String stuff = "fewpfjewfew"; one.stuff = stuff; one.setDao(dao); assertEquals(1, one.create()); }
@Test(expected = SQLException.class) public void testCreateNoDao() throws Exception { One one = new One(); String stuff = "fewpfjewfew"; one.stuff = stuff; one.create(); } |
### Question:
Parser implements ParserTreeConstants, ParserConstants { final public void StringLiteral() throws ParseException { ASTStringLiteral jjtn000 = new ASTStringLiteral(JJTSTRINGLITERAL); boolean jjtc000 = true; jjtree.openNodeScope(jjtn000); jjtn000.jjtSetFirstToken(getToken(1));Token t; try { t = jj_consume_token(STRING_LITERAL); jjtree.closeNodeScope(jjtn000, true); jjtc000 = false; jjtn000.jjtSetLastToken(getToken(0)); jjtn000.init(t.image); } finally { if (jjtc000) { jjtree.closeNodeScope(jjtn000, true); jjtn000.jjtSetLastToken(getToken(0)); } } } Parser(String s); Parser(java.io.InputStream stream); Parser(java.io.InputStream stream, String encoding); Parser(Reader stream); Parser(ParserTokenManager tm); final ASTRootNode parse(); final void DML(); final void Insert(); final void Delete(); final void Update(); final void Select(); final void Replace(); final void Merge(); final void Truncate(); final void Statement(); final void JDBCParameter(); final void JDBCIterableParameter(); final void GlobalTable(); final void JoinParameter(); final void QuoteText(); final void Text(); final void Blank(); final void IfStatement(); final void ElseStatement(); final void ElseIfStatement(); final void Expression(); final void ConditionalOrExpression(); final void ConditionalAndExpression(); final void RelationalExpression(); final void UnaryExpression(); final void PrimaryExpression(); final void ExpressionParameter(); final void IntegerLiteral(); final void StringLiteral(); final void True(); final void False(); final void Null(); void ReInit(java.io.InputStream stream); void ReInit(java.io.InputStream stream, String encoding); void ReInit(Reader stream); void ReInit(ParserTokenManager tm); final Token getNextToken(); final Token getToken(int index); ParseException generateParseException(); final void enable_tracing(); final void disable_tracing(); public ParserTokenManager token_source; public Token token; public Token jj_nt; }### Answer:
@Test public void testStringLiteral() throws Exception { String sql = "select #if (:1 == 'hello') ok #end"; ASTRootNode n = new Parser(sql).parse().init(); ParameterContext ctx = getParameterContext(Lists.newArrayList((Type) String.class)); n.checkAndBind(ctx); InvocationContext context = DefaultInvocationContext.create(); context.addParameter("1", "hello"); n.render(context); BoundSql boundSql = context.getBoundSql(); assertThat(boundSql.getSql(), Matchers.equalTo("select ok ")); } |
### Question:
BaseDaoEnabled { public int update() throws SQLException { checkForDao(); @SuppressWarnings("unchecked") T t = (T) this; return dao.update(t); } int create(); int refresh(); int update(); int updateId(ID newId); int delete(); String objectToString(); ID extractId(); boolean objectsEqual(T other); void setDao(Dao<T, ID> dao); Dao<T, ID> getDao(); }### Answer:
@Test public void testUpdate() throws Exception { Dao<One, Integer> dao = createDao(One.class, true); One one = new One(); String stuff1 = "fewpfjewfew"; one.stuff = stuff1; assertEquals(1, dao.create(one)); String stuff2 = "fjpfejpwewpfjewfew"; one.stuff = stuff2; assertEquals(1, one.update()); One one2 = dao.queryForId(one.id); assertEquals(stuff2, one2.stuff); } |
### Question:
BaseDaoEnabled { public int updateId(ID newId) throws SQLException { checkForDao(); @SuppressWarnings("unchecked") T t = (T) this; return dao.updateId(t, newId); } int create(); int refresh(); int update(); int updateId(ID newId); int delete(); String objectToString(); ID extractId(); boolean objectsEqual(T other); void setDao(Dao<T, ID> dao); Dao<T, ID> getDao(); }### Answer:
@Test public void testUpdateId() throws Exception { Dao<One, Integer> dao = createDao(One.class, true); One one = new One(); String stuff1 = "fewpfjewfew"; one.stuff = stuff1; assertEquals(1, dao.create(one)); int id = one.id; assertNotNull(dao.queryForId(id)); assertEquals(1, one.updateId(id + 1)); assertNull(dao.queryForId(id)); assertNotNull(dao.queryForId(id + 1)); } |
### Question:
BaseDaoEnabled { public int delete() throws SQLException { checkForDao(); @SuppressWarnings("unchecked") T t = (T) this; return dao.delete(t); } int create(); int refresh(); int update(); int updateId(ID newId); int delete(); String objectToString(); ID extractId(); boolean objectsEqual(T other); void setDao(Dao<T, ID> dao); Dao<T, ID> getDao(); }### Answer:
@Test public void testDelete() throws Exception { Dao<One, Integer> dao = createDao(One.class, true); One one = new One(); String stuff1 = "fewpfjewfew"; one.stuff = stuff1; assertEquals(1, dao.create(one)); assertNotNull(dao.queryForId(one.id)); assertEquals(1, one.delete()); assertNull(dao.queryForId(one.id)); } |
### Question:
BaseDaoEnabled { public String objectToString() { try { checkForDao(); } catch (SQLException e) { throw new IllegalArgumentException(e); } @SuppressWarnings("unchecked") T t = (T) this; return dao.objectToString(t); } int create(); int refresh(); int update(); int updateId(ID newId); int delete(); String objectToString(); ID extractId(); boolean objectsEqual(T other); void setDao(Dao<T, ID> dao); Dao<T, ID> getDao(); }### Answer:
@Test(expected = IllegalArgumentException.class) public void testObjectEqualsNoDao() { One one = new One(); String stuff1 = "fewpfjewfew"; one.stuff = stuff1; one.objectToString(); } |
### Question:
BaseDaoEnabled { public ID extractId() throws SQLException { checkForDao(); @SuppressWarnings("unchecked") T t = (T) this; return dao.extractId(t); } int create(); int refresh(); int update(); int updateId(ID newId); int delete(); String objectToString(); ID extractId(); boolean objectsEqual(T other); void setDao(Dao<T, ID> dao); Dao<T, ID> getDao(); }### Answer:
@Test public void testExtractId() throws Exception { Dao<One, Integer> dao = createDao(One.class, true); One one = new One(); String stuff1 = "fewpfjewfew"; one.stuff = stuff1; assertEquals(1, dao.create(one)); assertEquals(one.id, (int) one.extractId()); } |
### Question:
LocalLog implements Log { @Override public boolean isLevelEnabled(Level level) { return this.level.isEnabled(level); } LocalLog(String className); static void openLogFile(String logPath); @Override boolean isLevelEnabled(Level level); @Override void log(Level level, String msg); @Override void log(Level level, String msg, Throwable throwable); static final String LOCAL_LOG_LEVEL_PROPERTY; static final String LOCAL_LOG_FILE_PROPERTY; static final String LOCAL_LOG_PROPERTIES_FILE; }### Answer:
@Test public void testLevelProperty() { Log log = new LocalLog("foo"); if (log.isLevelEnabled(Level.TRACE)) { return; } System.setProperty(LocalLog.LOCAL_LOG_LEVEL_PROPERTY, "TRACE"); try { log = new LocalLog("foo"); assertTrue(log.isLevelEnabled(Level.TRACE)); } finally { System.clearProperty(LocalLog.LOCAL_LOG_LEVEL_PROPERTY); } } |
### Question:
LocalLog implements Log { public static void openLogFile(String logPath) { if (logPath == null) { printStream = System.out; } else { try { printStream = new PrintStream(new File(logPath)); } catch (FileNotFoundException e) { throw new IllegalArgumentException("Log file " + logPath + " was not found", e); } } } LocalLog(String className); static void openLogFile(String logPath); @Override boolean isLevelEnabled(Level level); @Override void log(Level level, String msg); @Override void log(Level level, String msg, Throwable throwable); static final String LOCAL_LOG_LEVEL_PROPERTY; static final String LOCAL_LOG_FILE_PROPERTY; static final String LOCAL_LOG_PROPERTIES_FILE; }### Answer:
@Test(expected = IllegalArgumentException.class) public void testInvalidFileProperty() { LocalLog.openLogFile("not-a-proper-directory-name-we-hope/foo.txt"); } |
### Question:
LocalLog implements Log { static List<PatternLevel> readLevelResourceFile(InputStream stream) { List<PatternLevel> levels = null; if (stream != null) { try { levels = configureClassLevels(stream); } catch (IOException e) { System.err.println( "IO exception reading the log properties file '" + LOCAL_LOG_PROPERTIES_FILE + "': " + e); } finally { IOUtils.closeQuietly(stream); } } return levels; } LocalLog(String className); static void openLogFile(String logPath); @Override boolean isLevelEnabled(Level level); @Override void log(Level level, String msg); @Override void log(Level level, String msg, Throwable throwable); static final String LOCAL_LOG_LEVEL_PROPERTY; static final String LOCAL_LOG_FILE_PROPERTY; static final String LOCAL_LOG_PROPERTIES_FILE; }### Answer:
@Test public void testInvalidLevelsFile() { StringWriter stringWriter = new StringWriter(); stringWriter.write("x\n"); stringWriter.write("com\\.j256\\.ormlite\\.stmt\\.StatementExecutor = INVALID_LEVEL\n"); LocalLog.readLevelResourceFile(new ByteArrayInputStream(stringWriter.toString().getBytes())); }
@Test public void testIoErrorsReadingLevelFile() { InputStream errorStream = new InputStream() { @Override public int read() throws IOException { throw new IOException("simulated exception"); } @Override public void close() throws IOException { throw new IOException("simulated exception"); } }; LocalLog.readLevelResourceFile(errorStream); }
@Test public void testInputStreamNull() { LocalLog.readLevelResourceFile(null); } |
### Question:
LoggerFactory { public static Logger getLogger(Class<?> clazz) { return getLogger(clazz.getName()); } private LoggerFactory(); static Logger getLogger(Class<?> clazz); static Logger getLogger(String className); static String getSimpleClassName(String className); static final String LOG_TYPE_SYSTEM_PROPERTY; }### Answer:
@Test public void testGetLoggerClass() { assertNotNull(LoggerFactory.getLogger(getClass())); }
@Test public void testGetLoggerString() { assertNotNull(LoggerFactory.getLogger(getClass().getName())); } |
### Question:
LoggerFactory { public static String getSimpleClassName(String className) { String[] parts = className.split("\\."); if (parts.length <= 1) { return className; } else { return parts[parts.length - 1]; } } private LoggerFactory(); static Logger getLogger(Class<?> clazz); static Logger getLogger(String className); static String getSimpleClassName(String className); static final String LOG_TYPE_SYSTEM_PROPERTY; }### Answer:
@Test public void testGetSimpleClassName() { String first = "foo"; String name = LoggerFactory.getSimpleClassName(first); assertEquals(first, name); String second = "bar"; String className = first + "." + second; name = LoggerFactory.getSimpleClassName(className); assertEquals(second, name); } |
### Question:
TableInfo { public TableInfo(ConnectionSource connectionSource, BaseDaoImpl<T, ID> baseDaoImpl, Class<T> dataClass) throws SQLException { this(connectionSource.getDatabaseType(), baseDaoImpl, DatabaseTableConfig.fromClass(connectionSource, dataClass)); } TableInfo(ConnectionSource connectionSource, BaseDaoImpl<T, ID> baseDaoImpl, Class<T> dataClass); TableInfo(DatabaseType databaseType, BaseDaoImpl<T, ID> baseDaoImpl, DatabaseTableConfig<T> tableConfig); Class<T> getDataClass(); String getTableName(); FieldType[] getFieldTypes(); FieldType getFieldTypeByColumnName(String columnName); FieldType getIdField(); Constructor<T> getConstructor(); String objectToString(T object); T createObject(); boolean isUpdatable(); boolean isForeignAutoCreate(); FieldType[] getForeignCollections(); boolean hasColumnName(String columnName); }### Answer:
@Test(expected = IllegalArgumentException.class) public void testTableInfo() throws SQLException { new TableInfo<NoFieldAnnotations, Void>(connectionSource, null, NoFieldAnnotations.class); } |
### Question:
TableInfo { public String objectToString(T object) { StringBuilder sb = new StringBuilder(64); sb.append(object.getClass().getSimpleName()); for (FieldType fieldType : fieldTypes) { sb.append(' ').append(fieldType.getColumnName()).append('='); try { sb.append(fieldType.extractJavaFieldValue(object)); } catch (Exception e) { throw new IllegalStateException("Could not generate toString of field " + fieldType, e); } } return sb.toString(); } TableInfo(ConnectionSource connectionSource, BaseDaoImpl<T, ID> baseDaoImpl, Class<T> dataClass); TableInfo(DatabaseType databaseType, BaseDaoImpl<T, ID> baseDaoImpl, DatabaseTableConfig<T> tableConfig); Class<T> getDataClass(); String getTableName(); FieldType[] getFieldTypes(); FieldType getFieldTypeByColumnName(String columnName); FieldType getIdField(); Constructor<T> getConstructor(); String objectToString(T object); T createObject(); boolean isUpdatable(); boolean isForeignAutoCreate(); FieldType[] getForeignCollections(); boolean hasColumnName(String columnName); }### Answer:
@Test public void testObjectToString() throws Exception { String id = "f11232oo"; Foo foo = new Foo(); foo.id = id; assertEquals(id, foo.id); TableInfo<Foo, String> tableInfo = new TableInfo<Foo, String>(connectionSource, null, Foo.class); assertTrue(tableInfo.objectToString(foo).contains(id)); } |
### Question:
TableInfo { public String getTableName() { return tableName; } TableInfo(ConnectionSource connectionSource, BaseDaoImpl<T, ID> baseDaoImpl, Class<T> dataClass); TableInfo(DatabaseType databaseType, BaseDaoImpl<T, ID> baseDaoImpl, DatabaseTableConfig<T> tableConfig); Class<T> getDataClass(); String getTableName(); FieldType[] getFieldTypes(); FieldType getFieldTypeByColumnName(String columnName); FieldType getIdField(); Constructor<T> getConstructor(); String objectToString(T object); T createObject(); boolean isUpdatable(); boolean isForeignAutoCreate(); FieldType[] getForeignCollections(); boolean hasColumnName(String columnName); }### Answer:
@Test public void testNoTableNameInAnnotation() throws Exception { TableInfo<NoTableNameAnnotation, Void> tableInfo = new TableInfo<NoTableNameAnnotation, Void>(connectionSource, null, NoTableNameAnnotation.class); assertEquals(NoTableNameAnnotation.class.getSimpleName().toLowerCase(), tableInfo.getTableName()); } |
### Question:
TableInfo { public T createObject() throws SQLException { try { T instance; ObjectFactory<T> factory = null; if (baseDaoImpl != null) { factory = baseDaoImpl.getObjectFactory(); } if (factory == null) { instance = constructor.newInstance(); } else { instance = factory.createObject(constructor, baseDaoImpl.getDataClass()); } wireNewInstance(baseDaoImpl, instance); return instance; } catch (Exception e) { throw SqlExceptionUtil.create("Could not create object for " + constructor.getDeclaringClass(), e); } } TableInfo(ConnectionSource connectionSource, BaseDaoImpl<T, ID> baseDaoImpl, Class<T> dataClass); TableInfo(DatabaseType databaseType, BaseDaoImpl<T, ID> baseDaoImpl, DatabaseTableConfig<T> tableConfig); Class<T> getDataClass(); String getTableName(); FieldType[] getFieldTypes(); FieldType getFieldTypeByColumnName(String columnName); FieldType getIdField(); Constructor<T> getConstructor(); String objectToString(T object); T createObject(); boolean isUpdatable(); boolean isForeignAutoCreate(); FieldType[] getForeignCollections(); boolean hasColumnName(String columnName); }### Answer:
@Test public void testConstruct() throws Exception { TableInfo<Foo, String> tableInfo = new TableInfo<Foo, String>(connectionSource, null, Foo.class); Foo foo = tableInfo.createObject(); assertNotNull(foo); } |
### Question:
TableInfo { public FieldType getFieldTypeByColumnName(String columnName) { if (fieldNameMap == null) { Map<String, FieldType> map = new HashMap<String, FieldType>(); for (FieldType fieldType : fieldTypes) { map.put(fieldType.getColumnName().toLowerCase(), fieldType); } fieldNameMap = map; } FieldType fieldType = fieldNameMap.get(columnName.toLowerCase()); if (fieldType != null) { return fieldType; } for (FieldType fieldType2 : fieldTypes) { if (fieldType2.getFieldName().equals(columnName)) { throw new IllegalArgumentException("You should use columnName '" + fieldType2.getColumnName() + "' for table " + tableName + " instead of fieldName '" + fieldType2.getFieldName() + "'"); } } throw new IllegalArgumentException("Unknown column name '" + columnName + "' in table " + tableName); } TableInfo(ConnectionSource connectionSource, BaseDaoImpl<T, ID> baseDaoImpl, Class<T> dataClass); TableInfo(DatabaseType databaseType, BaseDaoImpl<T, ID> baseDaoImpl, DatabaseTableConfig<T> tableConfig); Class<T> getDataClass(); String getTableName(); FieldType[] getFieldTypes(); FieldType getFieldTypeByColumnName(String columnName); FieldType getIdField(); Constructor<T> getConstructor(); String objectToString(T object); T createObject(); boolean isUpdatable(); boolean isForeignAutoCreate(); FieldType[] getForeignCollections(); boolean hasColumnName(String columnName); }### Answer:
@Test public void testUnknownForeignField() throws Exception { TableInfo<Foreign, Void> tableInfo = new TableInfo<Foreign, Void>(connectionSource, null, Foreign.class); try { tableInfo.getFieldTypeByColumnName("foo"); fail("expected exception"); } catch (IllegalArgumentException e) { assertTrue(e.getMessage().contains("'" + Foreign.FOREIGN_FIELD_NAME + "'")); assertTrue(e.getMessage().contains("'foo'")); } } |
### Question:
TableInfo { public boolean hasColumnName(String columnName) { for (FieldType fieldType : fieldTypes) { if (fieldType.getColumnName().equals(columnName)) { return true; } } return false; } TableInfo(ConnectionSource connectionSource, BaseDaoImpl<T, ID> baseDaoImpl, Class<T> dataClass); TableInfo(DatabaseType databaseType, BaseDaoImpl<T, ID> baseDaoImpl, DatabaseTableConfig<T> tableConfig); Class<T> getDataClass(); String getTableName(); FieldType[] getFieldTypes(); FieldType getFieldTypeByColumnName(String columnName); FieldType getIdField(); Constructor<T> getConstructor(); String objectToString(T object); T createObject(); boolean isUpdatable(); boolean isForeignAutoCreate(); FieldType[] getForeignCollections(); boolean hasColumnName(String columnName); }### Answer:
@Test public void testHasColumnName() throws Exception { Dao<Foo, String> dao = createDao(Foo.class, true); TableInfo<Foo, String> tableInfo = ((BaseDaoImpl<Foo, String>) dao).getTableInfo(); assertTrue(tableInfo.hasColumnName(COLUMN_NAME)); assertFalse(tableInfo.hasColumnName("not this name")); } |
### Question:
DatabaseTableConfigLoader { public static <T> void write(BufferedWriter writer, DatabaseTableConfig<T> config) throws SQLException { try { writeConfig(writer, config); } catch (IOException e) { throw SqlExceptionUtil.create("Could not write config to writer", e); } } static List<DatabaseTableConfig<?>> loadDatabaseConfigFromReader(BufferedReader reader); static DatabaseTableConfig<T> fromReader(BufferedReader reader); static void write(BufferedWriter writer, DatabaseTableConfig<T> config); }### Answer:
@Test public void testConfigFile() throws Exception { DatabaseTableConfig<NoFields> config = new DatabaseTableConfig<NoFields>(); StringBuilder body = new StringBuilder(); StringWriter writer = new StringWriter(); BufferedWriter buffer = new BufferedWriter(writer); Class<NoFields> clazz = NoFields.class; config.setDataClass(clazz); body.append("dataClass=").append(clazz.getName()).append(LINE_SEP); checkConfigOutput(config, body, writer, buffer, false); String tableName = "pojgefwpjoefwpjo"; config.setTableName(tableName); body.append("tableName=").append(tableName).append(LINE_SEP); checkConfigOutput(config, body, writer, buffer, false); DatabaseFieldConfig field1 = new DatabaseFieldConfig(); String columnName = "efjpowefpjoefw"; field1.setColumnName(columnName); config.setFieldConfigs(Arrays.asList(field1)); StringWriter fieldWriter = new StringWriter(); BufferedWriter fieldBuffer = new BufferedWriter(fieldWriter); DatabaseFieldConfigLoader.write(fieldBuffer, field1, tableName); fieldBuffer.flush(); body.append("# --table-fields-start--").append(LINE_SEP); body.append(fieldWriter.toString()); checkConfigOutput(config, body, writer, buffer, true); } |
### Question:
DatabaseTableConfigLoader { public static List<DatabaseTableConfig<?>> loadDatabaseConfigFromReader(BufferedReader reader) throws SQLException { List<DatabaseTableConfig<?>> list = new ArrayList<DatabaseTableConfig<?>>(); while (true) { DatabaseTableConfig<?> config = DatabaseTableConfigLoader.fromReader(reader); if (config == null) { break; } list.add(config); } return list; } static List<DatabaseTableConfig<?>> loadDatabaseConfigFromReader(BufferedReader reader); static DatabaseTableConfig<T> fromReader(BufferedReader reader); static void write(BufferedWriter writer, DatabaseTableConfig<T> config); }### Answer:
@Test public void testConfigEntriesFromStream() throws Exception { StringBuilder value = new StringBuilder(); value.append(TABLE_START); value.append("# random comment").append(LINE_SEP); value.append(LINE_SEP); value.append("dataClass=").append(Foo.class.getName()).append(LINE_SEP); String tableName = "fprwojfgopwejfw"; value.append("tableName=").append(tableName).append(LINE_SEP); value.append("# --table-fields-start--").append(LINE_SEP); value.append("# --field-start--").append(LINE_SEP); String fieldName = "weopjfwefjw"; value.append("fieldName=").append(fieldName).append(LINE_SEP); value.append("canBeNull=true").append(LINE_SEP); value.append("generatedId=true").append(LINE_SEP); value.append("# --field-end--").append(LINE_SEP); value.append("# --table-fields-end--").append(LINE_SEP); value.append(TABLE_END); List<DatabaseTableConfig<?>> tables = DatabaseTableConfigLoader.loadDatabaseConfigFromReader(new BufferedReader(new StringReader( value.toString()))); assertEquals(1, tables.size()); assertEquals(tableName, tables.get(0).getTableName()); DatabaseTableConfig<?> config = tables.get(0); List<DatabaseFieldConfig> fields = config.getFieldConfigs(); assertEquals(1, fields.size()); assertEquals(fieldName, fields.get(0).getFieldName()); }
@Test(expected = SQLException.class) public void testConfigInvalidLine() throws Exception { StringBuilder value = new StringBuilder(); value.append(TABLE_START); value.append("dataClass").append(LINE_SEP); DatabaseTableConfigLoader.loadDatabaseConfigFromReader(new BufferedReader(new StringReader(value.toString()))); }
@Test(expected = IllegalArgumentException.class) public void testConfigUnknownClass() throws Exception { StringBuilder value = new StringBuilder(); value.append(TABLE_START); value.append("dataClass=unknown.class.name.okay").append(LINE_SEP); value.append("# --table-fields-start--").append(LINE_SEP); value.append("# --field-start--").append(LINE_SEP); value.append("fieldName=xxx").append(LINE_SEP); value.append("# --field-end--").append(LINE_SEP); value.append("# --table-fields-end--").append(LINE_SEP); value.append(TABLE_END); DatabaseTableConfigLoader.loadDatabaseConfigFromReader(new BufferedReader(new StringReader(value.toString()))); }
@Test public void testQuickEndOfConfig() throws Exception { StringBuilder value = new StringBuilder(); value.append(TABLE_START); value.append("dataClass=").append(Foo.class.getName()).append(LINE_SEP); value.append("# --table-fields-start--").append(LINE_SEP); value.append("# --field-start--").append(LINE_SEP); value.append("fieldName=xxx").append(LINE_SEP); value.append("# --field-end--").append(LINE_SEP); value.append("# --field-start--").append(LINE_SEP); List<DatabaseTableConfig<?>> tables = DatabaseTableConfigLoader.loadDatabaseConfigFromReader(new BufferedReader(new StringReader( value.toString()))); assertEquals(1, tables.size()); DatabaseTableConfig<?> config = tables.get(0); List<DatabaseFieldConfig> fields = config.getFieldConfigs(); assertEquals(1, fields.size()); } |
### Question:
DatabaseTableConfig { public DatabaseTableConfig() { } DatabaseTableConfig(); DatabaseTableConfig(Class<T> dataClass, List<DatabaseFieldConfig> fieldConfigs); DatabaseTableConfig(Class<T> dataClass, String tableName, List<DatabaseFieldConfig> fieldConfigs); private DatabaseTableConfig(Class<T> dataClass, String tableName, FieldType[] fieldTypes); void initialize(); Class<T> getDataClass(); void setDataClass(Class<T> dataClass); String getTableName(); void setTableName(String tableName); void setFieldConfigs(List<DatabaseFieldConfig> fieldConfigs); void extractFieldTypes(ConnectionSource connectionSource); FieldType[] getFieldTypes(DatabaseType databaseType); List<DatabaseFieldConfig> getFieldConfigs(); Constructor<T> getConstructor(); void setConstructor(Constructor<T> constructor); static DatabaseTableConfig<T> fromClass(ConnectionSource connectionSource, Class<T> clazz); static String extractTableName(Class<T> clazz); static Constructor<T> findNoArgConstructor(Class<T> dataClass); }### Answer:
@Test public void testDatabaseTableConfig() throws SQLException { DatabaseTableConfig<DatabaseTableAnno> dbTableConf = DatabaseTableConfig.fromClass(connectionSource, DatabaseTableAnno.class); assertEquals(DatabaseTableAnno.class, dbTableConf.getDataClass()); assertEquals(TABLE_NAME, dbTableConf.getTableName()); dbTableConf.extractFieldTypes(connectionSource); FieldType[] fieldTypes = dbTableConf.getFieldTypes(databaseType); assertEquals(1, fieldTypes.length); assertEquals("stuff", fieldTypes[0].getColumnName()); } |
### Question:
DatabaseTableConfig { public void setFieldConfigs(List<DatabaseFieldConfig> fieldConfigs) { this.fieldConfigs = fieldConfigs; } DatabaseTableConfig(); DatabaseTableConfig(Class<T> dataClass, List<DatabaseFieldConfig> fieldConfigs); DatabaseTableConfig(Class<T> dataClass, String tableName, List<DatabaseFieldConfig> fieldConfigs); private DatabaseTableConfig(Class<T> dataClass, String tableName, FieldType[] fieldTypes); void initialize(); Class<T> getDataClass(); void setDataClass(Class<T> dataClass); String getTableName(); void setTableName(String tableName); void setFieldConfigs(List<DatabaseFieldConfig> fieldConfigs); void extractFieldTypes(ConnectionSource connectionSource); FieldType[] getFieldTypes(DatabaseType databaseType); List<DatabaseFieldConfig> getFieldConfigs(); Constructor<T> getConstructor(); void setConstructor(Constructor<T> constructor); static DatabaseTableConfig<T> fromClass(ConnectionSource connectionSource, Class<T> clazz); static String extractTableName(Class<T> clazz); static Constructor<T> findNoArgConstructor(Class<T> dataClass); }### Answer:
@Test public void testSetFieldConfigs() throws SQLException { DatabaseTableConfig<DatabaseTableAnno> dbTableConf = new DatabaseTableConfig<DatabaseTableAnno>(); dbTableConf.setDataClass(DatabaseTableAnno.class); dbTableConf.setTableName(TABLE_NAME); List<DatabaseFieldConfig> fieldConfigs = new ArrayList<DatabaseFieldConfig>(); fieldConfigs.add(new DatabaseFieldConfig("stuff", null, DataType.UNKNOWN, "", 0, true, false, false, null, false, null, false, null, false, null, false, null, null, false, DatabaseFieldConfig.NO_MAX_FOREIGN_AUTO_REFRESH_LEVEL_SPECIFIED, 0)); dbTableConf.setFieldConfigs(fieldConfigs); dbTableConf.initialize(); assertEquals(DatabaseTableAnno.class, dbTableConf.getDataClass()); assertEquals(TABLE_NAME, dbTableConf.getTableName()); dbTableConf.extractFieldTypes(connectionSource); FieldType[] fieldTypes = dbTableConf.getFieldTypes(databaseType); assertEquals(1, fieldTypes.length); assertEquals("stuff", fieldTypes[0].getColumnName()); } |
### Question:
DatabaseTableConfig { public void initialize() { if (dataClass == null) { throw new IllegalStateException("dataClass was never set on " + getClass().getSimpleName()); } if (tableName == null) { tableName = extractTableName(dataClass); } } DatabaseTableConfig(); DatabaseTableConfig(Class<T> dataClass, List<DatabaseFieldConfig> fieldConfigs); DatabaseTableConfig(Class<T> dataClass, String tableName, List<DatabaseFieldConfig> fieldConfigs); private DatabaseTableConfig(Class<T> dataClass, String tableName, FieldType[] fieldTypes); void initialize(); Class<T> getDataClass(); void setDataClass(Class<T> dataClass); String getTableName(); void setTableName(String tableName); void setFieldConfigs(List<DatabaseFieldConfig> fieldConfigs); void extractFieldTypes(ConnectionSource connectionSource); FieldType[] getFieldTypes(DatabaseType databaseType); List<DatabaseFieldConfig> getFieldConfigs(); Constructor<T> getConstructor(); void setConstructor(Constructor<T> constructor); static DatabaseTableConfig<T> fromClass(ConnectionSource connectionSource, Class<T> clazz); static String extractTableName(Class<T> clazz); static Constructor<T> findNoArgConstructor(Class<T> dataClass); }### Answer:
@Test(expected = IllegalStateException.class) public void testBadSpringWiring() { DatabaseTableConfig<NoFields> dbTableConf = new DatabaseTableConfig<NoFields>(); dbTableConf.initialize(); } |
### Question:
ConsoleLogger extends AbstractInternalLogger { @Override public void trace(String msg) { println(msg); } protected ConsoleLogger(String name); @Override boolean isTraceEnabled(); @Override void trace(String msg); @Override void trace(String format, Object arg); @Override void trace(String format, Object argA, Object argB); @Override void trace(String format, Object... arguments); @Override void trace(String msg, Throwable t); @Override boolean isDebugEnabled(); @Override void debug(String msg); @Override void debug(String format, Object arg); @Override void debug(String format, Object argA, Object argB); @Override void debug(String format, Object... arguments); @Override void debug(String msg, Throwable t); @Override boolean isInfoEnabled(); @Override void info(String msg); @Override void info(String format, Object arg); @Override void info(String format, Object argA, Object argB); @Override void info(String format, Object... arguments); @Override void info(String msg, Throwable t); @Override boolean isWarnEnabled(); @Override void warn(String msg); @Override void warn(String format, Object arg); @Override void warn(String format, Object... arguments); @Override void warn(String format, Object argA, Object argB); @Override void warn(String msg, Throwable t); @Override boolean isErrorEnabled(); @Override void error(String msg); @Override void error(String format, Object arg); @Override void error(String format, Object argA, Object argB); @Override void error(String format, Object... arguments); @Override void error(String msg, Throwable t); }### Answer:
@Test public void testMsg() throws Exception { ConsoleLogger logger = new ConsoleLogger("org"); logger.trace("ok"); } |
### Question:
DatabaseTableConfig { public FieldType[] getFieldTypes(DatabaseType databaseType) throws SQLException { if (fieldTypes == null) { throw new SQLException("Field types have not been extracted in table config"); } return fieldTypes; } DatabaseTableConfig(); DatabaseTableConfig(Class<T> dataClass, List<DatabaseFieldConfig> fieldConfigs); DatabaseTableConfig(Class<T> dataClass, String tableName, List<DatabaseFieldConfig> fieldConfigs); private DatabaseTableConfig(Class<T> dataClass, String tableName, FieldType[] fieldTypes); void initialize(); Class<T> getDataClass(); void setDataClass(Class<T> dataClass); String getTableName(); void setTableName(String tableName); void setFieldConfigs(List<DatabaseFieldConfig> fieldConfigs); void extractFieldTypes(ConnectionSource connectionSource); FieldType[] getFieldTypes(DatabaseType databaseType); List<DatabaseFieldConfig> getFieldConfigs(); Constructor<T> getConstructor(); void setConstructor(Constructor<T> constructor); static DatabaseTableConfig<T> fromClass(ConnectionSource connectionSource, Class<T> clazz); static String extractTableName(Class<T> clazz); static Constructor<T> findNoArgConstructor(Class<T> dataClass); }### Answer:
@Test(expected = SQLException.class) public void testNoFields() throws SQLException { new DatabaseTableConfig<DatabaseTableAnno>().getFieldTypes(databaseType); } |
### Question:
TableUtils { public static <T, ID> List<String> getCreateTableStatements(ConnectionSource connectionSource, Class<T> dataClass) throws SQLException { Dao<T, ID> dao = DaoManager.createDao(connectionSource, dataClass); if (dao instanceof BaseDaoImpl<?, ?>) { return addCreateTableStatements(connectionSource, ((BaseDaoImpl<?, ?>) dao).getTableInfo(), false); } else { TableInfo<T, ID> tableInfo = new TableInfo<T, ID>(connectionSource, null, dataClass); return addCreateTableStatements(connectionSource, tableInfo, false); } } private TableUtils(); static int createTable(ConnectionSource connectionSource, Class<T> dataClass); static int createTable(Dao<?, ?> dao); static int createTableIfNotExists(ConnectionSource connectionSource, Class<T> dataClass); static int createTable(ConnectionSource connectionSource, DatabaseTableConfig<T> tableConfig); static int createTableIfNotExists(ConnectionSource connectionSource, DatabaseTableConfig<T> tableConfig); static List<String> getCreateTableStatements(ConnectionSource connectionSource, Class<T> dataClass); static List<String> getCreateTableStatements(ConnectionSource connectionSource,
DatabaseTableConfig<T> tableConfig); static int dropTable(ConnectionSource connectionSource, Class<T> dataClass, boolean ignoreErrors); static int dropTable(Dao<T, ID> dao, boolean ignoreErrors); static int dropTable(ConnectionSource connectionSource, DatabaseTableConfig<T> tableConfig,
boolean ignoreErrors); static int clearTable(ConnectionSource connectionSource, Class<T> dataClass); static int clearTable(ConnectionSource connectionSource, DatabaseTableConfig<T> tableConfig); }### Answer:
@Test public void testCreateStatements() throws Exception { List<String> stmts = TableUtils.getCreateTableStatements(connectionSource, LocalFoo.class); assertEquals(1, stmts.size()); assertEquals(expectedCreateStatement(), stmts.get(0)); }
@Test public void testCreateStatementsTableConfig() throws Exception { List<String> stmts = TableUtils.getCreateTableStatements(connectionSource, DatabaseTableConfig.fromClass(connectionSource, LocalFoo.class)); assertEquals(1, stmts.size()); assertEquals(expectedCreateStatement(), stmts.get(0)); } |
### Question:
TableUtils { public static <T, ID> int dropTable(ConnectionSource connectionSource, Class<T> dataClass, boolean ignoreErrors) throws SQLException { Dao<T, ID> dao = DaoManager.createDao(connectionSource, dataClass); return dropTable(dao, ignoreErrors); } private TableUtils(); static int createTable(ConnectionSource connectionSource, Class<T> dataClass); static int createTable(Dao<?, ?> dao); static int createTableIfNotExists(ConnectionSource connectionSource, Class<T> dataClass); static int createTable(ConnectionSource connectionSource, DatabaseTableConfig<T> tableConfig); static int createTableIfNotExists(ConnectionSource connectionSource, DatabaseTableConfig<T> tableConfig); static List<String> getCreateTableStatements(ConnectionSource connectionSource, Class<T> dataClass); static List<String> getCreateTableStatements(ConnectionSource connectionSource,
DatabaseTableConfig<T> tableConfig); static int dropTable(ConnectionSource connectionSource, Class<T> dataClass, boolean ignoreErrors); static int dropTable(Dao<T, ID> dao, boolean ignoreErrors); static int dropTable(ConnectionSource connectionSource, DatabaseTableConfig<T> tableConfig,
boolean ignoreErrors); static int clearTable(ConnectionSource connectionSource, Class<T> dataClass); static int clearTable(ConnectionSource connectionSource, DatabaseTableConfig<T> tableConfig); }### Answer:
@Test public void testDropTable() throws Exception { final ConnectionSource connectionSource = createMock(ConnectionSource.class); testDrop("localfoo", connectionSource, 0, false, new Callable<Integer>() { @Override public Integer call() throws Exception { return (int) TableUtils.dropTable(connectionSource, LocalFoo.class, false); } }); }
@Test(expected = SQLException.class) public void testDropTableThrow() throws Exception { final ConnectionSource connectionSource = createMock(ConnectionSource.class); testDrop("localfoo", connectionSource, 0, true, new Callable<Integer>() { @Override public Integer call() throws Exception { return (int) TableUtils.dropTable(connectionSource, LocalFoo.class, false); } }); }
@Test public void testDropTableThrowIgnore() throws Exception { final ConnectionSource connectionSource = createMock(ConnectionSource.class); testDrop("localfoo", connectionSource, 0, true, new Callable<Integer>() { @Override public Integer call() throws Exception { return (int) TableUtils.dropTable(connectionSource, LocalFoo.class, true); } }); }
@Test(expected = SQLException.class) public void testDropTableNegRows() throws Exception { final ConnectionSource connectionSource = createMock(ConnectionSource.class); testDrop("localfoo", connectionSource, -1, false, new Callable<Integer>() { @Override public Integer call() throws Exception { return (int) TableUtils.dropTable(connectionSource, LocalFoo.class, false); } }); }
@Test public void testDropTableTableConfig() throws Exception { final ConnectionSource connectionSource = createMock(ConnectionSource.class); testDrop("localfoo", connectionSource, 0, false, new Callable<Integer>() { @Override public Integer call() throws Exception { return (int) TableUtils.dropTable(connectionSource, DatabaseTableConfig.fromClass(connectionSource, LocalFoo.class), false); } }); }
@Test public void testDropThenQuery() throws Exception { Dao<LocalFoo, Integer> fooDao = createDao(LocalFoo.class, true); assertEquals(0, fooDao.queryForAll().size()); dropTable(LocalFoo.class, true); try { fooDao.queryForAll(); fail("Should have thrown"); } catch (SQLException e) { } } |
### Question:
TableUtils { public static <T> int clearTable(ConnectionSource connectionSource, Class<T> dataClass) throws SQLException { String tableName = DatabaseTableConfig.extractTableName(dataClass); DatabaseType databaseType = connectionSource.getDatabaseType(); if (databaseType.isEntityNamesMustBeUpCase()) { tableName = databaseType.upCaseEntityName(tableName); } return clearTable(connectionSource, tableName); } private TableUtils(); static int createTable(ConnectionSource connectionSource, Class<T> dataClass); static int createTable(Dao<?, ?> dao); static int createTableIfNotExists(ConnectionSource connectionSource, Class<T> dataClass); static int createTable(ConnectionSource connectionSource, DatabaseTableConfig<T> tableConfig); static int createTableIfNotExists(ConnectionSource connectionSource, DatabaseTableConfig<T> tableConfig); static List<String> getCreateTableStatements(ConnectionSource connectionSource, Class<T> dataClass); static List<String> getCreateTableStatements(ConnectionSource connectionSource,
DatabaseTableConfig<T> tableConfig); static int dropTable(ConnectionSource connectionSource, Class<T> dataClass, boolean ignoreErrors); static int dropTable(Dao<T, ID> dao, boolean ignoreErrors); static int dropTable(ConnectionSource connectionSource, DatabaseTableConfig<T> tableConfig,
boolean ignoreErrors); static int clearTable(ConnectionSource connectionSource, Class<T> dataClass); static int clearTable(ConnectionSource connectionSource, DatabaseTableConfig<T> tableConfig); }### Answer:
@Test public void testClearTable() throws Exception { Dao<LocalFoo, Integer> fooDao = createDao(LocalFoo.class, true); assertEquals(0, fooDao.countOf()); LocalFoo foo = new LocalFoo(); assertEquals(1, fooDao.create(foo)); assertEquals(1, fooDao.countOf()); TableUtils.clearTable(connectionSource, LocalFoo.class); assertEquals(0, fooDao.countOf()); } |
### Question:
TableUtils { public static <T> int createTableIfNotExists(ConnectionSource connectionSource, Class<T> dataClass) throws SQLException { Dao<T, ?> dao = DaoManager.createDao(connectionSource, dataClass); return doCreateTable(dao, true); } private TableUtils(); static int createTable(ConnectionSource connectionSource, Class<T> dataClass); static int createTable(Dao<?, ?> dao); static int createTableIfNotExists(ConnectionSource connectionSource, Class<T> dataClass); static int createTable(ConnectionSource connectionSource, DatabaseTableConfig<T> tableConfig); static int createTableIfNotExists(ConnectionSource connectionSource, DatabaseTableConfig<T> tableConfig); static List<String> getCreateTableStatements(ConnectionSource connectionSource, Class<T> dataClass); static List<String> getCreateTableStatements(ConnectionSource connectionSource,
DatabaseTableConfig<T> tableConfig); static int dropTable(ConnectionSource connectionSource, Class<T> dataClass, boolean ignoreErrors); static int dropTable(Dao<T, ID> dao, boolean ignoreErrors); static int dropTable(ConnectionSource connectionSource, DatabaseTableConfig<T> tableConfig,
boolean ignoreErrors); static int clearTable(ConnectionSource connectionSource, Class<T> dataClass); static int clearTable(ConnectionSource connectionSource, DatabaseTableConfig<T> tableConfig); }### Answer:
@Test public void testCreateTableIfNotExists() throws Exception { dropTable(LocalFoo.class, true); Dao<LocalFoo, Integer> fooDao = createDao(LocalFoo.class, false); try { fooDao.countOf(); fail("Should have thrown an exception"); } catch (Exception e) { } TableUtils.createTableIfNotExists(connectionSource, LocalFoo.class); assertEquals(0, fooDao.countOf()); TableUtils.createTableIfNotExists(connectionSource, LocalFoo.class); assertEquals(0, fooDao.countOf()); } |
### Question:
BaseDatabaseType implements DatabaseType { @Override public void loadDriver() throws SQLException { String className = getDriverClassName(); if (className != null) { try { Class.forName(className); } catch (ClassNotFoundException e) { throw SqlExceptionUtil.create("Driver class was not found for " + getDatabaseName() + " database. Missing jar with class " + className + ".", e); } } } @Override void loadDriver(); @Override void setDriver(Driver driver); @Override void appendColumnArg(String tableName, StringBuilder sb, FieldType fieldType, List<String> additionalArgs,
List<String> statementsBefore, List<String> statementsAfter, List<String> queriesAfter); @Override void addPrimaryKeySql(FieldType[] fieldTypes, List<String> additionalArgs, List<String> statementsBefore,
List<String> statementsAfter, List<String> queriesAfter); @Override void addUniqueComboSql(FieldType[] fieldTypes, List<String> additionalArgs, List<String> statementsBefore,
List<String> statementsAfter, List<String> queriesAfter); @Override void dropColumnArg(FieldType fieldType, List<String> statementsBefore, List<String> statementsAfter); @Override void appendEscapedWord(StringBuilder sb, String word); @Override void appendEscapedEntityName(StringBuilder sb, String name); @Override String generateIdSequenceName(String tableName, FieldType idFieldType); @Override String getCommentLinePrefix(); @Override DataPersister getDataPersister(DataPersister defaultPersister, FieldType fieldType); @Override FieldConverter getFieldConverter(DataPersister dataPersister, FieldType fieldType); @Override boolean isIdSequenceNeeded(); @Override boolean isVarcharFieldWidthSupported(); @Override boolean isLimitSqlSupported(); @Override boolean isOffsetSqlSupported(); @Override boolean isOffsetLimitArgument(); @Override boolean isLimitAfterSelect(); @Override void appendLimitValue(StringBuilder sb, long limit, Long offset); @Override void appendOffsetValue(StringBuilder sb, long offset); @Override void appendSelectNextValFromSequence(StringBuilder sb, String sequenceName); @Override void appendCreateTableSuffix(StringBuilder sb); @Override boolean isCreateTableReturnsZero(); @Override boolean isCreateTableReturnsNegative(); @Override boolean isEntityNamesMustBeUpCase(); @Override String upCaseEntityName(String entityName); @Override boolean isNestedSavePointsSupported(); @Override String getPingStatement(); @Override boolean isBatchUseTransaction(); @Override boolean isTruncateSupported(); @Override boolean isCreateIfNotExistsSupported(); @Override boolean isCreateIndexIfNotExistsSupported(); @Override boolean isSelectSequenceBeforeInsert(); @Override boolean isAllowGeneratedIdInsertSupported(); @Override DatabaseTableConfig<T> extractDatabaseTableConfig(ConnectionSource connectionSource, Class<T> clazz); @Override void appendInsertNoColumns(StringBuilder sb); }### Answer:
@Test(expected = SQLException.class) public void testDriverNotFound() throws SQLException { new TestDatabaseType().loadDriver(); } |
### Question:
BaseDatabaseType implements DatabaseType { protected void configureGeneratedId(String tableName, StringBuilder sb, FieldType fieldType, List<String> statementsBefore, List<String> statementsAfter, List<String> additionalArgs, List<String> queriesAfter) { throw new IllegalStateException( "GeneratedId is not supported by database " + getDatabaseName() + " for field " + fieldType); } @Override void loadDriver(); @Override void setDriver(Driver driver); @Override void appendColumnArg(String tableName, StringBuilder sb, FieldType fieldType, List<String> additionalArgs,
List<String> statementsBefore, List<String> statementsAfter, List<String> queriesAfter); @Override void addPrimaryKeySql(FieldType[] fieldTypes, List<String> additionalArgs, List<String> statementsBefore,
List<String> statementsAfter, List<String> queriesAfter); @Override void addUniqueComboSql(FieldType[] fieldTypes, List<String> additionalArgs, List<String> statementsBefore,
List<String> statementsAfter, List<String> queriesAfter); @Override void dropColumnArg(FieldType fieldType, List<String> statementsBefore, List<String> statementsAfter); @Override void appendEscapedWord(StringBuilder sb, String word); @Override void appendEscapedEntityName(StringBuilder sb, String name); @Override String generateIdSequenceName(String tableName, FieldType idFieldType); @Override String getCommentLinePrefix(); @Override DataPersister getDataPersister(DataPersister defaultPersister, FieldType fieldType); @Override FieldConverter getFieldConverter(DataPersister dataPersister, FieldType fieldType); @Override boolean isIdSequenceNeeded(); @Override boolean isVarcharFieldWidthSupported(); @Override boolean isLimitSqlSupported(); @Override boolean isOffsetSqlSupported(); @Override boolean isOffsetLimitArgument(); @Override boolean isLimitAfterSelect(); @Override void appendLimitValue(StringBuilder sb, long limit, Long offset); @Override void appendOffsetValue(StringBuilder sb, long offset); @Override void appendSelectNextValFromSequence(StringBuilder sb, String sequenceName); @Override void appendCreateTableSuffix(StringBuilder sb); @Override boolean isCreateTableReturnsZero(); @Override boolean isCreateTableReturnsNegative(); @Override boolean isEntityNamesMustBeUpCase(); @Override String upCaseEntityName(String entityName); @Override boolean isNestedSavePointsSupported(); @Override String getPingStatement(); @Override boolean isBatchUseTransaction(); @Override boolean isTruncateSupported(); @Override boolean isCreateIfNotExistsSupported(); @Override boolean isCreateIndexIfNotExistsSupported(); @Override boolean isSelectSequenceBeforeInsert(); @Override boolean isAllowGeneratedIdInsertSupported(); @Override DatabaseTableConfig<T> extractDatabaseTableConfig(ConnectionSource connectionSource, Class<T> clazz); @Override void appendInsertNoColumns(StringBuilder sb); }### Answer:
@Test(expected = IllegalStateException.class) public void testConfigureGeneratedId() { new TestDatabaseType().configureGeneratedId(null, new StringBuilder(), null, new ArrayList<String>(), null, new ArrayList<String>(), new ArrayList<String>()); } |
### Question:
BaseSqliteDatabaseType extends BaseDatabaseType { @Override protected void configureGeneratedId(String tableName, StringBuilder sb, FieldType fieldType, List<String> statementsBefore, List<String> statementsAfter, List<String> additionalArgs, List<String> queriesAfter) { if (fieldType.getSqlType() != SqlType.INTEGER && fieldType.getSqlType() != SqlType.LONG) { throw new IllegalArgumentException( "Sqlite requires that auto-increment generated-id be integer or long type"); } sb.append("PRIMARY KEY AUTOINCREMENT "); } @Override boolean isVarcharFieldWidthSupported(); @Override boolean isCreateTableReturnsZero(); @Override boolean isCreateIfNotExistsSupported(); @Override FieldConverter getFieldConverter(DataPersister dataPersister, FieldType fieldType); @Override void appendInsertNoColumns(StringBuilder sb); }### Answer:
@Test(expected = IllegalArgumentException.class) public void testConfigureGeneratedIdNotInteger() throws Exception { Field field = Foo.class.getField("stringField"); FieldType fieldType = FieldType.createFieldType(connectionSource, "foo", field, Foo.class); OurSqliteDatabaseType dbType = new OurSqliteDatabaseType(); StringBuilder sb = new StringBuilder(); dbType.configureGeneratedId(null, sb, fieldType, new ArrayList<String>(), null, new ArrayList<String>(), new ArrayList<String>()); }
@Test public void testConfigureGeneratedIdInteger() throws Exception { Field field = Foo.class.getField("val"); FieldType fieldType = FieldType.createFieldType(connectionSource, "foo", field, Foo.class); OurSqliteDatabaseType dbType = new OurSqliteDatabaseType(); StringBuilder sb = new StringBuilder(); dbType.configureGeneratedId(null, sb, fieldType, new ArrayList<String>(), null, new ArrayList<String>(), new ArrayList<String>()); assertTrue(sb.toString().contains("PRIMARY KEY AUTOINCREMENT")); } |
### Question:
BaseSqliteDatabaseType extends BaseDatabaseType { @Override public boolean isVarcharFieldWidthSupported() { return false; } @Override boolean isVarcharFieldWidthSupported(); @Override boolean isCreateTableReturnsZero(); @Override boolean isCreateIfNotExistsSupported(); @Override FieldConverter getFieldConverter(DataPersister dataPersister, FieldType fieldType); @Override void appendInsertNoColumns(StringBuilder sb); }### Answer:
@Test public void testIsVarcharFieldWidthSupported() { assertFalse(new OurSqliteDatabaseType().isVarcharFieldWidthSupported()); } |
### Question:
BaseSqliteDatabaseType extends BaseDatabaseType { @Override public boolean isCreateTableReturnsZero() { return false; } @Override boolean isVarcharFieldWidthSupported(); @Override boolean isCreateTableReturnsZero(); @Override boolean isCreateIfNotExistsSupported(); @Override FieldConverter getFieldConverter(DataPersister dataPersister, FieldType fieldType); @Override void appendInsertNoColumns(StringBuilder sb); }### Answer:
@Test public void testIsCreateTableReturnsZero() { assertFalse(new OurSqliteDatabaseType().isCreateTableReturnsZero()); } |
### Question:
BaseSqliteDatabaseType extends BaseDatabaseType { @Override protected boolean generatedIdSqlAtEnd() { return false; } @Override boolean isVarcharFieldWidthSupported(); @Override boolean isCreateTableReturnsZero(); @Override boolean isCreateIfNotExistsSupported(); @Override FieldConverter getFieldConverter(DataPersister dataPersister, FieldType fieldType); @Override void appendInsertNoColumns(StringBuilder sb); }### Answer:
@Test public void testGeneratedIdSqlAtEnd() { assertFalse(new OurSqliteDatabaseType().generatedIdSqlAtEnd()); } |
### Question:
BaseSqliteDatabaseType extends BaseDatabaseType { @Override public boolean isCreateIfNotExistsSupported() { return true; } @Override boolean isVarcharFieldWidthSupported(); @Override boolean isCreateTableReturnsZero(); @Override boolean isCreateIfNotExistsSupported(); @Override FieldConverter getFieldConverter(DataPersister dataPersister, FieldType fieldType); @Override void appendInsertNoColumns(StringBuilder sb); }### Answer:
@Test public void testIsCreateIfNotExistsSupported() { assertTrue(new OurSqliteDatabaseType().isCreateIfNotExistsSupported()); } |
### Question:
BaseSqliteDatabaseType extends BaseDatabaseType { @Override public FieldConverter getFieldConverter(DataPersister dataPersister, FieldType fieldType) { switch (dataPersister.getSqlType()) { case BOOLEAN : return booleanConverter; case BIG_DECIMAL : return BigDecimalStringType.getSingleton(); default : return super.getFieldConverter(dataPersister, fieldType); } } @Override boolean isVarcharFieldWidthSupported(); @Override boolean isCreateTableReturnsZero(); @Override boolean isCreateIfNotExistsSupported(); @Override FieldConverter getFieldConverter(DataPersister dataPersister, FieldType fieldType); @Override void appendInsertNoColumns(StringBuilder sb); }### Answer:
@Test public void testGetFieldConverter() throws Exception { OurSqliteDatabaseType dbType = new OurSqliteDatabaseType(); assertEquals(Byte.valueOf((byte) 1), dbType.getFieldConverter(DataType.BOOLEAN.getDataPersister(), null) .parseDefaultString(null, "true")); }
@Test public void testDefaultFieldConverter() { OurSqliteDatabaseType dbType = new OurSqliteDatabaseType(); assertSame(DataType.STRING.getDataPersister(), dbType.getFieldConverter(DataType.STRING.getDataPersister(), null)); } |
### Question:
FieldType { @Override public boolean equals(Object arg) { if (arg == null || arg.getClass() != this.getClass()) { return false; } FieldType other = (FieldType) arg; return field.equals(other.field) && (parentClass == null ? other.parentClass == null : parentClass.equals(other.parentClass)); } FieldType(ConnectionSource connectionSource, String tableName, Field field, DatabaseFieldConfig fieldConfig,
Class<?> parentClass); void configDaoInformation(ConnectionSource connectionSource, Class<?> parentClass); Field getField(); String getTableName(); String getFieldName(); Class<?> getType(); Type getGenericType(); String getColumnName(); DataPersister getDataPersister(); Object getDataTypeConfigObj(); SqlType getSqlType(); Object getDefaultValue(); int getWidth(); boolean isCanBeNull(); boolean isId(); boolean isGeneratedId(); boolean isGeneratedIdSequence(); String getGeneratedIdSequence(); boolean isForeign(); void assignField(Object data, Object val, boolean parentObject, ObjectCache objectCache); Object assignIdValue(Object data, Number val, ObjectCache objectCache); FV extractRawJavaFieldValue(Object object); Object extractJavaFieldValue(Object object); Object extractJavaFieldToSqlArgValue(Object object); Object convertJavaFieldToSqlArgValue(Object fieldVal); Object convertStringToJavaField(String value, int columnPos); Object moveToNextValue(Object val); FieldType getForeignIdField(); FieldType getForeignRefField(); boolean isEscapedValue(); Enum<?> getUnknownEnumVal(); String getFormat(); boolean isUnique(); boolean isUniqueCombo(); String getIndexName(); String getUniqueIndexName(); boolean isEscapedDefaultValue(); boolean isComparable(); boolean isArgumentHolderRequired(); boolean isForeignCollection(); BaseForeignCollection<FT, FID> buildForeignCollection(Object parent, FID id); T resultToJava(DatabaseResults results, Map<String, Integer> columnPositions); boolean isSelfGeneratedId(); boolean isAllowGeneratedIdInsert(); String getColumnDefinition(); boolean isForeignAutoCreate(); boolean isVersion(); Object generateId(); boolean isReadOnly(); FV getFieldValueIfNotDefault(Object object); boolean isObjectsFieldValueDefault(Object object); Object getJavaDefaultValueDefault(); int createWithForeignDao(T foreignData); static FieldType createFieldType(ConnectionSource connectionSource, String tableName, Field field,
Class<?> parentClass); @Override boolean equals(Object arg); @Override int hashCode(); @Override String toString(); static final String FOREIGN_ID_FIELD_SUFFIX; }### Answer:
@Test public void testEquals() throws Exception { Field field1 = DefaultTypes.class.getDeclaredField("booleanField"); FieldType fieldType1 = FieldType.createFieldType(connectionSource, DefaultTypes.class.getSimpleName(), field1, DefaultTypes.class); FieldType fieldType2 = FieldType.createFieldType(connectionSource, DefaultTypes.class.getSimpleName(), field1, DefaultTypes.class); Field field2 = DefaultTypes.class.getDeclaredField("byteField"); FieldType fieldType3 = FieldType.createFieldType(connectionSource, DefaultTypes.class.getSimpleName(), field2, DefaultTypes.class); FieldType fieldType4 = FieldType.createFieldType(connectionSource, DefaultTypes.class.getSimpleName(), field2, DefaultTypes.class); assertTrue(fieldType1.equals(fieldType1)); assertTrue(fieldType2.equals(fieldType2)); assertTrue(fieldType1.equals(fieldType2)); assertTrue(fieldType2.equals(fieldType1)); assertEquals(fieldType1.hashCode(), fieldType2.hashCode()); assertFalse(fieldType1.equals(null)); assertFalse(fieldType1.equals(fieldType3)); assertFalse(fieldType1.equals(fieldType4)); assertFalse(fieldType3.equals(fieldType1)); assertFalse(fieldType4.equals(fieldType1)); assertTrue(fieldType3.equals(fieldType3)); assertTrue(fieldType4.equals(fieldType4)); assertTrue(fieldType3.equals(fieldType4)); assertTrue(fieldType4.equals(fieldType3)); assertEquals(fieldType3.hashCode(), fieldType4.hashCode()); } |
### Question:
DatabaseFieldConfigLoader { public static DatabaseFieldConfig fromReader(BufferedReader reader) throws SQLException { DatabaseFieldConfig config = new DatabaseFieldConfig(); boolean anything = false; while (true) { String line; try { line = reader.readLine(); } catch (IOException e) { throw SqlExceptionUtil.create("Could not read DatabaseFieldConfig from stream", e); } if (line == null) { break; } if (line.equals(CONFIG_FILE_END_MARKER)) { break; } if (line.length() == 0 || line.startsWith("#") || line.equals(CONFIG_FILE_START_MARKER)) { continue; } String[] parts = line.split("=", -2); if (parts.length != 2) { throw new SQLException("DatabaseFieldConfig reading from stream cannot parse line: " + line); } readField(config, parts[0], parts[1]); anything = true; } if (anything) { return config; } else { return null; } } static DatabaseFieldConfig fromReader(BufferedReader reader); static void write(BufferedWriter writer, DatabaseFieldConfig config, String tableName); static void writeConfig(BufferedWriter writer, DatabaseFieldConfig config, String tableName); }### Answer:
@Test public void testEmptyFile() throws Exception { String value = ""; assertNull(DatabaseFieldConfigLoader.fromReader(new BufferedReader(new StringReader(value)))); }
@Test(expected = SQLException.class) public void testBadLine() throws Exception { String value = "not a good line"; DatabaseFieldConfigLoader.fromReader(new BufferedReader(new StringReader(value))); }
@Test public void testBlankLine() throws Exception { String value = LINE_SEP; assertNull(DatabaseFieldConfigLoader.fromReader(new BufferedReader(new StringReader(value)))); }
@Test public void testComment() throws Exception { String value = "# some comment" + LINE_SEP; assertNull(DatabaseFieldConfigLoader.fromReader(new BufferedReader(new StringReader(value)))); }
@Test(expected = IllegalArgumentException.class) public void testBadPersisterClass() throws Exception { String value = "persisterClass=unknown class name" + LINE_SEP; DatabaseFieldConfigLoader.fromReader(new BufferedReader(new StringReader(value))); }
@Test(expected = IllegalArgumentException.class) public void testBadEnumValue() throws Exception { String value = "unknownEnumValue=notvalidclass" + LINE_SEP; DatabaseFieldConfigLoader.fromReader(new BufferedReader(new StringReader(value))); }
@Test(expected = IllegalArgumentException.class) public void testBadEnumClass() throws Exception { String value = "unknownEnumValue=notvalidclass#somevalue" + LINE_SEP; DatabaseFieldConfigLoader.fromReader(new BufferedReader(new StringReader(value))); }
@Test(expected = IllegalArgumentException.class) public void testBadEnumClassNotAnEnum() throws Exception { String value = "unknownEnumValue=java.lang.Object#somevalue" + LINE_SEP; DatabaseFieldConfigLoader.fromReader(new BufferedReader(new StringReader(value))); }
@Test(expected = IllegalArgumentException.class) public void testBadEnumClassInvalidEnumValue() throws Exception { String value = "unknownEnumValue=" + OurEnum.class.getName() + "#notvalid" + LINE_SEP; DatabaseFieldConfigLoader.fromReader(new BufferedReader(new StringReader(value))); } |
### Question:
DateLongType extends BaseDateType { @Override public Object parseDefaultString(FieldType fieldType, String defaultStr) throws SQLException { try { return Long.parseLong(defaultStr); } catch (NumberFormatException e) { throw SqlExceptionUtil.create("Problems with field " + fieldType + " parsing default date-long value: " + defaultStr, e); } } private DateLongType(); protected DateLongType(SqlType sqlType, Class<?>[] classes); static DateLongType getSingleton(); @Override Object parseDefaultString(FieldType fieldType, String defaultStr); @Override Object resultToSqlArg(FieldType fieldType, DatabaseResults results, int columnPos); @Override Object sqlArgToJava(FieldType fieldType, Object sqlArg, int columnPos); @Override Object javaToSqlArg(FieldType fieldType, Object obj); @Override boolean isEscapedValue(); @Override Class<?> getPrimaryClass(); }### Answer:
@Test(expected = SQLException.class) public void testDateLongParseInvalid() throws Exception { FieldType fieldType = FieldType.createFieldType(connectionSource, TABLE_NAME, LocalDateLong.class.getDeclaredField(DATE_COLUMN), LocalDateLong.class); DataType.DATE_LONG.getDataPersister().parseDefaultString(fieldType, "not valid long number"); } |
### Question:
SerializableType extends BaseDataType { @Override public Object parseDefaultString(FieldType fieldType, String defaultStr) throws SQLException { throw new SQLException("Default values for serializable types are not supported"); } private SerializableType(); protected SerializableType(SqlType sqlType, Class<?>[] classes); static SerializableType getSingleton(); @Override Object parseDefaultString(FieldType fieldType, String defaultStr); @Override Object resultToSqlArg(FieldType fieldType, DatabaseResults results, int columnPos); @Override Object sqlArgToJava(FieldType fieldType, Object sqlArg, int columnPos); @Override Object javaToSqlArg(FieldType fieldType, Object obj); @Override boolean isValidForField(Field field); @Override boolean isStreamType(); @Override boolean isComparable(); @Override boolean isAppropriateId(); @Override boolean isArgumentHolderRequired(); @Override Object resultStringToJava(FieldType fieldType, String stringValue, int columnPos); @Override Class<?> getPrimaryClass(); }### Answer:
@Test(expected = SQLException.class) public void testSerializableParseDefault() throws Exception { DataType.SERIALIZABLE.getDataPersister().parseDefaultString(null, null); } |
### Question:
DateTimeType extends BaseDataType { @Override public Object javaToSqlArg(FieldType fieldType, Object javaObject) throws SQLException { return extractMillis(javaObject); } private DateTimeType(); protected DateTimeType(SqlType sqlType, Class<?>[] classes); static DateTimeType getSingleton(); @Override String[] getAssociatedClassNames(); @Override Object javaToSqlArg(FieldType fieldType, Object javaObject); @Override Object parseDefaultString(FieldType fieldType, String defaultStr); @Override Object resultToSqlArg(FieldType fieldType, DatabaseResults results, int columnPos); @Override Object sqlArgToJava(FieldType fieldType, Object sqlArg, int columnPos); @Override boolean isEscapedValue(); @Override boolean isAppropriateId(); @Override Class<?> getPrimaryClass(); @Override boolean isValidForVersion(); @Override Object moveToNextValue(Object currentValue); }### Answer:
@Test(expected = SQLException.class) public void testJavaToSqlArg() throws Exception { DateTimeType.getSingleton().javaToSqlArg(null, new Object()); } |
### Question:
DateTimeType extends BaseDataType { @Override public Object parseDefaultString(FieldType fieldType, String defaultStr) throws SQLException { try { return Long.parseLong(defaultStr); } catch (NumberFormatException e) { throw SqlExceptionUtil.create("Problems with field " + fieldType + " parsing default DateTime value: " + defaultStr, e); } } private DateTimeType(); protected DateTimeType(SqlType sqlType, Class<?>[] classes); static DateTimeType getSingleton(); @Override String[] getAssociatedClassNames(); @Override Object javaToSqlArg(FieldType fieldType, Object javaObject); @Override Object parseDefaultString(FieldType fieldType, String defaultStr); @Override Object resultToSqlArg(FieldType fieldType, DatabaseResults results, int columnPos); @Override Object sqlArgToJava(FieldType fieldType, Object sqlArg, int columnPos); @Override boolean isEscapedValue(); @Override boolean isAppropriateId(); @Override Class<?> getPrimaryClass(); @Override boolean isValidForVersion(); @Override Object moveToNextValue(Object currentValue); }### Answer:
@Test public void testParseDefaultString() throws SQLException { Long value = 423424234234L; assertEquals(value, DateTimeType.getSingleton().parseDefaultString(null, value.toString())); } |
### Question:
DateTimeType extends BaseDataType { @Override public Object resultToSqlArg(FieldType fieldType, DatabaseResults results, int columnPos) throws SQLException { return results.getLong(columnPos); } private DateTimeType(); protected DateTimeType(SqlType sqlType, Class<?>[] classes); static DateTimeType getSingleton(); @Override String[] getAssociatedClassNames(); @Override Object javaToSqlArg(FieldType fieldType, Object javaObject); @Override Object parseDefaultString(FieldType fieldType, String defaultStr); @Override Object resultToSqlArg(FieldType fieldType, DatabaseResults results, int columnPos); @Override Object sqlArgToJava(FieldType fieldType, Object sqlArg, int columnPos); @Override boolean isEscapedValue(); @Override boolean isAppropriateId(); @Override Class<?> getPrimaryClass(); @Override boolean isValidForVersion(); @Override Object moveToNextValue(Object currentValue); }### Answer:
@Test(expected = SQLException.class) public void testResultToSqlArg() throws Exception { DatabaseResults results = createMock(DatabaseResults.class); int col = 21; long value = 2094234324L; expect(results.getLong(col)).andReturn(value); replay(results); DateTimeType.getSingleton().resultToJava(null, results, col); } |
### Question:
DateType extends BaseDateType { @Override public Object parseDefaultString(FieldType fieldType, String defaultStr) throws SQLException { DateStringFormatConfig dateFormatConfig = convertDateStringConfig(fieldType, getDefaultDateFormatConfig()); try { return new Timestamp(parseDateString(dateFormatConfig, defaultStr).getTime()); } catch (ParseException e) { throw SqlExceptionUtil.create("Problems parsing default date string '" + defaultStr + "' using '" + dateFormatConfig + '\'', e); } } private DateType(); protected DateType(SqlType sqlType, Class<?>[] classes); static DateType getSingleton(); @Override Object parseDefaultString(FieldType fieldType, String defaultStr); @Override Object resultToSqlArg(FieldType fieldType, DatabaseResults results, int columnPos); @Override Object sqlArgToJava(FieldType fieldType, Object sqlArg, int columnPos); @Override Object javaToSqlArg(FieldType fieldType, Object javaObject); @Override boolean isArgumentHolderRequired(); }### Answer:
@Test(expected = SQLException.class) public void testDateParseInvalid() throws Exception { FieldType fieldType = FieldType.createFieldType(connectionSource, TABLE_NAME, LocalDate.class.getDeclaredField(DATE_COLUMN), LocalDate.class); DataType.DATE.getDataPersister().parseDefaultString(fieldType, "not valid date string"); } |
### Question:
BindingParameter { public String getFullName() { return Strings.getFullName(parameterName, propertyPath); } BindingParameter(String parameterName, String propertyPath, JdbcType jdbcType); static BindingParameter create(String parameterName, String propertyPath, JdbcType jdbcType); BindingParameter rightShift(); String getParameterName(); String getPropertyPath(); JdbcType getJdbcType(); String getFullName(); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); }### Answer:
@Test public void testGetFullName() throws Exception { BindingParameter bp = BindingParameter.create("a", "b", null); assertThat(bp.getFullName(), equalTo(":a.b")); bp = BindingParameter.create("a", "", null); assertThat(bp.getFullName(), equalTo(":a")); } |
### Question:
BindingParameter { @Override public boolean equals(Object obj) { if (obj == null) return false; if (getClass() != obj.getClass()) return false; final BindingParameter other = (BindingParameter) obj; return Objects.equal(this.getParameterName(), other.getParameterName()) && Objects.equal(this.getPropertyPath(), other.getPropertyPath()) && Objects.equal(this.getJdbcType(), other.getJdbcType()); } BindingParameter(String parameterName, String propertyPath, JdbcType jdbcType); static BindingParameter create(String parameterName, String propertyPath, JdbcType jdbcType); BindingParameter rightShift(); String getParameterName(); String getPropertyPath(); JdbcType getJdbcType(); String getFullName(); @Override boolean equals(Object obj); @Override int hashCode(); @Override String toString(); }### Answer:
@Test public void testEquals() throws Exception { BindingParameter bp = BindingParameter.create("a", "b", null); BindingParameter bp2 = BindingParameter.create("a", "b", null); assertThat(bp.equals(bp2), equalTo(true)); assertThat(bp.equals(null), equalTo(false)); assertThat(bp.equals(new Object()), equalTo(false)); } |
### Question:
FunctionalBindingParameterInvoker implements BindingParameterInvoker { public static FunctionalBindingParameterInvoker create( Type originalType, BindingParameter bindingParameter) { try { FunctionalBindingParameterInvoker invokerGroup = new FunctionalBindingParameterInvoker(originalType, bindingParameter); return invokerGroup; } catch (UnreachablePropertyException e) { throw new BindingException("Parameter '" + bindingParameter + "' can't be readable", e); } } private FunctionalBindingParameterInvoker(Type originalType, BindingParameter bindingParameter); static FunctionalBindingParameterInvoker create(
Type originalType, BindingParameter bindingParameter); @Override Type getTargetType(); @Override Object invoke(Object obj); @Override BindingParameter getBindingParameter(); }### Answer:
@Test public void testBindingException4() throws Exception { thrown.expect(BindingException.class); thrown.expectMessage("Parameter ':user.userBag.ite' can't be readable; " + "caused by: There is no getter/setter for property named 'ite' in 'class org.jfaster.mango.binding.FunctionalBindingParameterInvokerTest$UserBag'"); FunctionalBindingParameterInvoker.create(User.class, BindingParameter.create("user", "userBag.ite", null)); } |
### Question:
BeanUtil { public static List<PropertyMeta> fetchPropertyMetas(Class<?> clazz) { return cache.get(clazz); } static List<PropertyMeta> fetchPropertyMetas(Class<?> clazz); }### Answer:
@Test public void fetchPropertyMetas() throws Exception { Set<PropertyMeta> pms = Sets.newHashSet(BeanUtil.fetchPropertyMetas(A.class)); Set<PropertyMeta> set = Sets.newHashSet(); set.add(getPropertyMeta(A.class, "id", int.class)); set.add(getPropertyMeta(A.class, "uid", int.class)); set.add(getPropertyMeta(A.class, "name", String.class)); assertThat(pms, equalTo(set)); } |
### Question:
InvocationContextFactory { public InvocationContext newInvocationContext(Object[] values) { InvocationContext context = DefaultInvocationContext.create(); for (int i = 0; i < values.length; i++) { String parameterName = parameterContext.getParameterNameByPosition(i); context.addParameter(parameterName, values[i]); } return context; } private InvocationContextFactory(ParameterContext parameterContext); static InvocationContextFactory create(ParameterContext parameterContext); InvocationContext newInvocationContext(Object[] values); }### Answer:
@Test public void testNewInvocationContext() throws Exception { List<Annotation> empty = Collections.emptyList(); ParameterDescriptor p0 = ParameterDescriptor.create(0, String.class, empty, "name"); ParameterDescriptor p1 = ParameterDescriptor.create(1, int.class, empty, "id"); List<ParameterDescriptor> pds = Arrays.asList(p0, p1); ParameterContext paramCtx = DefaultParameterContext.create(pds); InvocationContextFactory factory = InvocationContextFactory.create(paramCtx); InvocationContext invCtx = factory.newInvocationContext(new Object[]{"ash", 9527}); BindingParameterInvoker nameInvoker = FunctionalBindingParameterInvoker.create(String.class, BindingParameter.create("name", "", null)); BindingParameterInvoker idInvoker = FunctionalBindingParameterInvoker.create(String.class, BindingParameter.create("id", "", null)); assertThat(invCtx.getNullableBindingValue(nameInvoker), equalTo((Object) "ash")); assertThat(invCtx.getNullableBindingValue(idInvoker), equalTo((Object) 9527)); } |
### Question:
LruObjectCache implements ObjectCache { @Override public <T> int size(Class<T> clazz) { Map<Object, Object> objectMap = getMapForClass(clazz); if (objectMap == null) { return 0; } else { return objectMap.size(); } } LruObjectCache(int capacity); @Override synchronized void registerClass(Class<T> clazz); @Override T get(Class<T> clazz, ID id); @Override void put(Class<T> clazz, ID id, T data); @Override void clear(Class<T> clazz); @Override void clearAll(); @Override void remove(Class<T> clazz, ID id); @Override T updateId(Class<T> clazz, ID oldId, ID newId); @Override int size(Class<T> clazz); @Override int sizeAll(); }### Answer:
@Test public void testStuff() throws Exception { Dao<Foo, Integer> dao = createDao(Foo.class, true); LruObjectCache cache = new LruObjectCache(2); dao.setObjectCache(cache); Foo foo1 = new Foo(); int val = 12312321; foo1.val = val; assertEquals(1, dao.create(foo1)); assertEquals(1, cache.size(Foo.class)); Foo result = dao.queryForId(foo1.id); assertSame(foo1, result); Foo foo2 = new Foo(); int val2 = 21234761; foo2.val = val2; assertEquals(1, dao.create(foo2)); assertEquals(2, cache.size(Foo.class)); result = dao.queryForId(foo2.id); assertSame(foo2, result); result = dao.queryForId(foo2.id); assertSame(foo2, result); Foo foo3 = new Foo(); int val3 = 79834761; foo3.val = val3; assertEquals(1, dao.create(foo3)); assertEquals(2, cache.size(Foo.class)); result = dao.queryForId(foo1.id); assertNotSame(foo1, result); foo1 = result; result = dao.queryForId(foo2.id); assertNotSame(foo2, result); foo2 = result; result = dao.queryForId(foo1.id); assertSame(foo1, result); result = dao.queryForId(foo2.id); assertSame(foo2, result); } |
### Question:
LruObjectCache implements ObjectCache { @Override public <T> void clear(Class<T> clazz) { Map<Object, Object> objectMap = getMapForClass(clazz); if (objectMap != null) { objectMap.clear(); } } LruObjectCache(int capacity); @Override synchronized void registerClass(Class<T> clazz); @Override T get(Class<T> clazz, ID id); @Override void put(Class<T> clazz, ID id, T data); @Override void clear(Class<T> clazz); @Override void clearAll(); @Override void remove(Class<T> clazz, ID id); @Override T updateId(Class<T> clazz, ID oldId, ID newId); @Override int size(Class<T> clazz); @Override int sizeAll(); }### Answer:
@Test public void testClear() throws Exception { Dao<Foo, Integer> dao = createDao(Foo.class, true); LruObjectCache cache = new LruObjectCache(2); dao.setObjectCache(cache); Foo foo = new Foo(); int val = 12312321; foo.val = val; assertEquals(1, dao.create(foo)); assertEquals(1, cache.size(Foo.class)); Foo result = dao.queryForId(foo.id); assertSame(foo, result); dao.clearObjectCache(); result = dao.queryForId(foo.id); assertNotSame(foo, result); } |
### Question:
EagerForeignCollection extends BaseForeignCollection<T, ID> implements CloseableWrappedIterable<T>,
Serializable { @Override public boolean contains(Object o) { return results.contains(o); } EagerForeignCollection(Dao<T, ID> dao, Object parent, Object parentId, FieldType foreignFieldType,
String orderColumn, boolean orderAscending); @Override CloseableIterator<T> iterator(); @Override CloseableIterator<T> iterator(int flags); @Override CloseableIterator<T> closeableIterator(); @Override CloseableIterator<T> closeableIterator(int flags); @Override CloseableIterator<T> iteratorThrow(); @Override CloseableIterator<T> iteratorThrow(int flags); @Override CloseableWrappedIterable<T> getWrappedIterable(); @Override CloseableWrappedIterable<T> getWrappedIterable(int flags); @Override void close(); @Override void closeLastIterator(); @Override boolean isEager(); @Override int size(); @Override boolean isEmpty(); @Override boolean contains(Object o); @Override boolean containsAll(Collection<?> c); @Override Object[] toArray(); @Override E[] toArray(E[] array); @Override boolean add(T data); @Override boolean addAll(Collection<? extends T> collection); @Override boolean remove(Object data); @Override boolean removeAll(Collection<?> collection); @Override boolean retainAll(Collection<?> collection); @Override int updateAll(); @Override int refreshAll(); @Override int refreshCollection(); @Override boolean equals(Object obj); @Override int hashCode(); }### Answer:
@Test public void testContains() throws Exception { Dao<Eager, Integer> eagerDao = createDao(Eager.class, true); Dao<Foreign, Integer> foreignDao = createDao(Foreign.class, true); Eager eager = new Eager(); assertEquals(1, eagerDao.create(eager)); Foreign f0 = new Foreign(); f0.eager = eager; assertEquals(1, foreignDao.create(f0)); Foreign f1 = new Foreign(); f1.eager = eager; assertEquals(1, foreignDao.create(f1)); Eager result = eagerDao.queryForId(eager.id); for (Foreign foreign : result.foreignCollection) { assertTrue(result.foreignCollection.contains(foreign)); } } |
### Question:
DaoManager { public synchronized static <D extends Dao<T, ?>, T> D createDao(ConnectionSource connectionSource, Class<T> clazz) throws SQLException { if (connectionSource == null) { throw new IllegalArgumentException("connectionSource argument cannot be null"); } ClassConnectionSource key = new ClassConnectionSource(connectionSource, clazz); Dao<?, ?> dao = lookupDao(key); if (dao != null) { @SuppressWarnings("unchecked") D castDao = (D) dao; return castDao; } dao = createDaoFromConfig(connectionSource, clazz); if (dao != null) { @SuppressWarnings("unchecked") D castDao = (D) dao; return castDao; } DatabaseTable databaseTable = clazz.getAnnotation(DatabaseTable.class); if (databaseTable == null || databaseTable.daoClass() == Void.class || databaseTable.daoClass() == BaseDaoImpl.class) { DatabaseType databaseType = connectionSource.getDatabaseType(); DatabaseTableConfig<T> config = databaseType.extractDatabaseTableConfig(connectionSource, clazz); Dao<T, ?> daoTmp; if (config == null) { daoTmp = BaseDaoImpl.createDao(connectionSource, clazz); } else { daoTmp = BaseDaoImpl.createDao(connectionSource, config); } dao = daoTmp; logger.debug("created dao for class {} with reflection", clazz); } else { Class<?> daoClass = databaseTable.daoClass(); Object[] arguments = new Object[] { connectionSource, clazz }; Constructor<?> daoConstructor = findConstructor(daoClass, arguments); if (daoConstructor == null) { arguments = new Object[] { connectionSource }; daoConstructor = findConstructor(daoClass, arguments); if (daoConstructor == null) { throw new SQLException( "Could not find public constructor with ConnectionSource and optional Class parameters " + daoClass + ". Missing static on class?"); } } try { dao = (Dao<?, ?>) daoConstructor.newInstance(arguments); logger.debug("created dao for class {} from constructor", clazz); } catch (Exception e) { throw SqlExceptionUtil.create("Could not call the constructor in class " + daoClass, e); } } registerDao(connectionSource, dao); @SuppressWarnings("unchecked") D castDao = (D) dao; return castDao; } synchronized static D createDao(ConnectionSource connectionSource, Class<T> clazz); synchronized static D lookupDao(ConnectionSource connectionSource, Class<T> clazz); synchronized static D createDao(ConnectionSource connectionSource,
DatabaseTableConfig<T> tableConfig); synchronized static D lookupDao(ConnectionSource connectionSource,
DatabaseTableConfig<T> tableConfig); static synchronized void registerDao(ConnectionSource connectionSource, Dao<?, ?> dao); static synchronized void unregisterDao(ConnectionSource connectionSource, Dao<?, ?> dao); static synchronized void registerDaoWithTableConfig(ConnectionSource connectionSource, Dao<?, ?> dao); static synchronized void clearCache(); static synchronized void clearDaoCache(); static synchronized void addCachedDatabaseConfigs(Collection<DatabaseTableConfig<?>> configs); }### Answer:
@Test(expected = IllegalArgumentException.class) public void testCreateDaoNull() throws Exception { DaoManager.createDao(null, Foo.class); }
@Test(expected = IllegalArgumentException.class) public void testCreateDaoTableNull() throws Exception { DaoManager.createDao(null, new DatabaseTableConfig<Foo>()); }
@Test public void testDaoClassGenericDaoMethod() throws Exception { GenericDao<GenericBaz, String> bazdao = DaoManager.createDao(connectionSource, GenericBaz.class); assertSame(GenericBaz.class.getName(), bazdao.doGenericAction()); GenericDao<GenericBar, Void> bardao = DaoManager.createDao(connectionSource, GenericBar.class); assertSame(GenericBar.class.getName(), bardao.doGenericAction()); } |
### Question:
DaoManager { public synchronized static <D extends Dao<T, ?>, T> D lookupDao(ConnectionSource connectionSource, Class<T> clazz) { if (connectionSource == null) { throw new IllegalArgumentException("connectionSource argument cannot be null"); } ClassConnectionSource key = new ClassConnectionSource(connectionSource, clazz); Dao<?, ?> dao = lookupDao(key); @SuppressWarnings("unchecked") D castDao = (D) dao; return castDao; } synchronized static D createDao(ConnectionSource connectionSource, Class<T> clazz); synchronized static D lookupDao(ConnectionSource connectionSource, Class<T> clazz); synchronized static D createDao(ConnectionSource connectionSource,
DatabaseTableConfig<T> tableConfig); synchronized static D lookupDao(ConnectionSource connectionSource,
DatabaseTableConfig<T> tableConfig); static synchronized void registerDao(ConnectionSource connectionSource, Dao<?, ?> dao); static synchronized void unregisterDao(ConnectionSource connectionSource, Dao<?, ?> dao); static synchronized void registerDaoWithTableConfig(ConnectionSource connectionSource, Dao<?, ?> dao); static synchronized void clearCache(); static synchronized void clearDaoCache(); static synchronized void addCachedDatabaseConfigs(Collection<DatabaseTableConfig<?>> configs); }### Answer:
@Test(expected = IllegalArgumentException.class) public void testLookupDaoNull() { DaoManager.lookupDao(null, Foo.class); }
@Test public void testLookupDaoUnknown() { assertNull(DaoManager.lookupDao(connectionSource, getClass())); }
@Test(expected = IllegalArgumentException.class) public void testLookupDaoTableNull() { DaoManager.lookupDao(null, new DatabaseTableConfig<Foo>()); }
@Test public void testLookupTableDaoUnknown() { assertNull(DaoManager.lookupDao(connectionSource, new DatabaseTableConfig<DaoManagerTest>(DaoManagerTest.class, new ArrayList<DatabaseFieldConfig>()))); } |
### Question:
DaoManager { public static synchronized void registerDao(ConnectionSource connectionSource, Dao<?, ?> dao) { if (connectionSource == null) { throw new IllegalArgumentException("connectionSource argument cannot be null"); } addDaoToClassMap(new ClassConnectionSource(connectionSource, dao.getDataClass()), dao); } synchronized static D createDao(ConnectionSource connectionSource, Class<T> clazz); synchronized static D lookupDao(ConnectionSource connectionSource, Class<T> clazz); synchronized static D createDao(ConnectionSource connectionSource,
DatabaseTableConfig<T> tableConfig); synchronized static D lookupDao(ConnectionSource connectionSource,
DatabaseTableConfig<T> tableConfig); static synchronized void registerDao(ConnectionSource connectionSource, Dao<?, ?> dao); static synchronized void unregisterDao(ConnectionSource connectionSource, Dao<?, ?> dao); static synchronized void registerDaoWithTableConfig(ConnectionSource connectionSource, Dao<?, ?> dao); static synchronized void clearCache(); static synchronized void clearDaoCache(); static synchronized void addCachedDatabaseConfigs(Collection<DatabaseTableConfig<?>> configs); }### Answer:
@Test public void testRegisterDao() throws Exception { Dao<RegisterClass, Void> dao = DaoManager.lookupDao(connectionSource, RegisterClass.class); assertNull(dao); Dao<? extends RegisterClass, Object> daoImpl = BaseDaoImpl.createDao(connectionSource, RegisterClass.class); DaoManager.registerDao(connectionSource, daoImpl); dao = DaoManager.lookupDao(connectionSource, RegisterClass.class); assertSame(daoImpl, dao); }
@Test(expected = IllegalArgumentException.class) public void testRegisterNull() { DaoManager.registerDao(null, null); } |
### Question:
DefaultInvocationContext implements InvocationContext { @Override @Nullable public Object getNullableBindingValue(BindingParameterInvoker invoker) { String key = getCacheKey(invoker); if (cache.containsKey(key)) { return cache.get(key); } String parameterName = invoker.getBindingParameter().getParameterName(); if (!parameterNameToValueMap.containsKey(parameterName)) { throw new BindingException("Parameter '" + BindingParameter.create(parameterName, "", null) + "' not found, " + "available root parameters are " + transToBindingParameters(parameterNameToValueMap.keySet())); } Object obj = parameterNameToValueMap.get(parameterName); Object value = invoker.invoke(obj); cache.put(key, value); return value; } private DefaultInvocationContext(); static DefaultInvocationContext create(); @Override void addParameter(String parameterName, Object parameterValue); @Override Object getBindingValue(BindingParameterInvoker invoker); @Override @Nullable Object getNullableBindingValue(BindingParameterInvoker invoker); @Override void setBindingValue(BindingParameterInvoker invoker, Object value); @Override @Nullable String getGlobalTable(); @Override void setGlobalTable(String globalTable); @Override void writeToSqlBuffer(String str); @Override void appendToArgs(Object obj, TypeHandler<?> typeHandler); @Override BoundSql getBoundSql(); @Override List<Object> getParameterValues(); }### Answer:
@Test public void testGetNullableBindingValue() throws Exception { DefaultInvocationContext ctx = DefaultInvocationContext.create(); UserBag userBag = new UserBag(); userBag.setName("ash"); User user = new User(); user.setUserBag(userBag); user.setId(100); ctx.addParameter("userId", 9527); ctx.addParameter("user", user); BindingParameterInvoker userIdInvoker = FunctionalBindingParameterInvoker.create(User.class, BindingParameter.create("userId", "", null)); assertThat(ctx.getNullableBindingValue(userIdInvoker), equalTo((Object) 9527)); assertThat(ctx.getNullableBindingValue(userIdInvoker), equalTo((Object) 9527)); BindingParameterInvoker userDotIdInvoker = FunctionalBindingParameterInvoker.create(User.class, BindingParameter.create("user", "id", null)); assertThat(ctx.getNullableBindingValue(userDotIdInvoker), equalTo((Object) 100)); assertThat(ctx.getNullableBindingValue(userDotIdInvoker), equalTo((Object) 100)); BindingParameterInvoker userDotObjIdInvoker = FunctionalBindingParameterInvoker.create(User.class, BindingParameter.create("user", "objId", null)); assertThat(ctx.getNullableBindingValue(userDotObjIdInvoker), nullValue()); assertThat(ctx.getNullableBindingValue(userDotObjIdInvoker), nullValue()); BindingParameterInvoker userDotUserBagDotNameInvoker = FunctionalBindingParameterInvoker.create(User.class, BindingParameter.create("user", "userBag.name", null)); assertThat(ctx.getNullableBindingValue(userDotUserBagDotNameInvoker), equalTo((Object) "ash")); assertThat(ctx.getNullableBindingValue(userDotUserBagDotNameInvoker), equalTo((Object) "ash")); } |
### Question:
DefaultInvocationContext implements InvocationContext { @Override public Object getBindingValue(BindingParameterInvoker invoker) { Object value = getNullableBindingValue(invoker); if (value == null) { throw new BindingException("Parameter '" + invoker.getBindingParameter() + "' need a non-null value"); } return value; } private DefaultInvocationContext(); static DefaultInvocationContext create(); @Override void addParameter(String parameterName, Object parameterValue); @Override Object getBindingValue(BindingParameterInvoker invoker); @Override @Nullable Object getNullableBindingValue(BindingParameterInvoker invoker); @Override void setBindingValue(BindingParameterInvoker invoker, Object value); @Override @Nullable String getGlobalTable(); @Override void setGlobalTable(String globalTable); @Override void writeToSqlBuffer(String str); @Override void appendToArgs(Object obj, TypeHandler<?> typeHandler); @Override BoundSql getBoundSql(); @Override List<Object> getParameterValues(); }### Answer:
@Test public void testGetBindingValue() throws Exception { DefaultInvocationContext ctx = DefaultInvocationContext.create(); ctx.addParameter("userId", 9527); BindingParameterInvoker userIdInvoker = FunctionalBindingParameterInvoker.create(User.class, BindingParameter.create("userId", "", null)); assertThat(ctx.getBindingValue(userIdInvoker), equalTo((Object) 9527)); } |
### Question:
DefaultInvocationContext implements InvocationContext { @Override public void setBindingValue(BindingParameterInvoker invoker, Object value) { String key = getCacheKey(invoker); cache.put(key, value); } private DefaultInvocationContext(); static DefaultInvocationContext create(); @Override void addParameter(String parameterName, Object parameterValue); @Override Object getBindingValue(BindingParameterInvoker invoker); @Override @Nullable Object getNullableBindingValue(BindingParameterInvoker invoker); @Override void setBindingValue(BindingParameterInvoker invoker, Object value); @Override @Nullable String getGlobalTable(); @Override void setGlobalTable(String globalTable); @Override void writeToSqlBuffer(String str); @Override void appendToArgs(Object obj, TypeHandler<?> typeHandler); @Override BoundSql getBoundSql(); @Override List<Object> getParameterValues(); }### Answer:
@Test public void testSetBindingValue() throws Exception { DefaultInvocationContext ctx = DefaultInvocationContext.create(); ctx.addParameter("userId", 9527); BindingParameterInvoker userIdInvoker = FunctionalBindingParameterInvoker.create(User.class, BindingParameter.create("userId", "", null)); assertThat(ctx.getBindingValue(userIdInvoker), equalTo((Object) 9527)); ctx.setBindingValue(userIdInvoker, 666); assertThat(ctx.getBindingValue(userIdInvoker), equalTo((Object) 666)); } |
### Question:
DefaultParameterContext implements ParameterContext { @Override public String getParameterNameByPosition(int position) { String name = positionToNameMap.get(position); if (name == null) { throw new IllegalStateException("parameter name can not be found by position [" + position + "]"); } return name; } private DefaultParameterContext(List<ParameterDescriptor> parameterDescriptors); static DefaultParameterContext create(List<ParameterDescriptor> parameterDescriptors); @Override String getParameterNameByPosition(int position); @Override BindingParameterInvoker getBindingParameterInvoker(BindingParameter bindingParameter); @Override List<ParameterDescriptor> getParameterDescriptors(); @Override @Nullable BindingParameter tryExpandBindingParameter(BindingParameter bindingParameter); }### Answer:
@Test public void testGetParameterNameByPosition() throws Exception { List<Annotation> empty = Collections.emptyList(); ParameterDescriptor p0 = ParameterDescriptor.create(0, String.class, empty, "param1"); ParameterDescriptor p1 = ParameterDescriptor.create(1, int.class, empty, "param2"); List<ParameterDescriptor> pds = Arrays.asList(p0, p1); ParameterContext ctx = DefaultParameterContext.create(pds); assertThat(ctx.getParameterNameByPosition(0), equalTo("param1")); assertThat(ctx.getParameterNameByPosition(1), equalTo("param2")); } |
### Question:
DefaultParameterContext implements ParameterContext { @Override public BindingParameterInvoker getBindingParameterInvoker(BindingParameter bindingParameter) { String parameterName = bindingParameter.getParameterName(); Type type = nameToTypeMap.get(parameterName); if (type == null) { throw new BindingException("Parameter '" + BindingParameter.create(bindingParameter.getParameterName(), "", null) + "' not found, available root parameters are " + transToBindingParameters(nameToTypeMap.keySet())); } return FunctionalBindingParameterInvoker.create(type, bindingParameter); } private DefaultParameterContext(List<ParameterDescriptor> parameterDescriptors); static DefaultParameterContext create(List<ParameterDescriptor> parameterDescriptors); @Override String getParameterNameByPosition(int position); @Override BindingParameterInvoker getBindingParameterInvoker(BindingParameter bindingParameter); @Override List<ParameterDescriptor> getParameterDescriptors(); @Override @Nullable BindingParameter tryExpandBindingParameter(BindingParameter bindingParameter); }### Answer:
@Test public void testGetBindingParameterInvoker() throws Exception { List<Annotation> empty = Collections.emptyList(); ParameterDescriptor p0 = ParameterDescriptor.create(0, String.class, empty, "1"); ParameterDescriptor p1 = ParameterDescriptor.create(1, User.class, empty, "2"); List<ParameterDescriptor> pds = Arrays.asList(p0, p1); ParameterContext ctx = DefaultParameterContext.create(pds); checkBindingParameterInvoker(ctx, "1", "", String.class); checkBindingParameterInvoker(ctx, "2", "userBag.item.itemId", int.class); checkBindingParameterInvoker(ctx, "2", "userBag.item.objItemId", Integer.class); checkBindingParameterInvoker(ctx, "2", "userId", String.class); } |
### Question:
DefaultParameterContext implements ParameterContext { @Override public List<ParameterDescriptor> getParameterDescriptors() { return parameterDescriptors; } private DefaultParameterContext(List<ParameterDescriptor> parameterDescriptors); static DefaultParameterContext create(List<ParameterDescriptor> parameterDescriptors); @Override String getParameterNameByPosition(int position); @Override BindingParameterInvoker getBindingParameterInvoker(BindingParameter bindingParameter); @Override List<ParameterDescriptor> getParameterDescriptors(); @Override @Nullable BindingParameter tryExpandBindingParameter(BindingParameter bindingParameter); }### Answer:
@Test public void testGetParameterDescriptors() throws Exception { List<Annotation> empty = Collections.emptyList(); ParameterDescriptor p0 = ParameterDescriptor.create(0, String.class, empty, "1"); ParameterDescriptor p1 = ParameterDescriptor.create(1, User.class, empty, "2"); List<ParameterDescriptor> pds = Arrays.asList(p0, p1); ParameterContext ctx = DefaultParameterContext.create(pds); assertThat(ctx.getParameterDescriptors(), equalTo(pds)); } |
### Question:
BaseConnectionSource implements ConnectionSource { @Override public DatabaseConnection getSpecialConnection(String tableName) { NestedConnection currentSaved = specialConnection.get(); if (currentSaved == null) { return null; } else { return currentSaved.connection; } } @Override DatabaseConnection getSpecialConnection(String tableName); }### Answer:
@Test public void testNestedSave() throws Exception { OurConnectionSource cs = new OurConnectionSource(); DatabaseConnection conn = cs.getReadOnlyConnection(null); cs.saveSpecialConnection(conn); cs.saveSpecialConnection(conn); cs.clearSpecialConnection(conn); assertEquals(conn, cs.getSpecialConnection(null)); cs.close(); } |
### Question:
DatabaseConnectionProxy implements DatabaseConnection { @Override public boolean isAutoCommitSupported() throws SQLException { if (proxy == null) { return false; } else { return proxy.isAutoCommitSupported(); } } DatabaseConnectionProxy(DatabaseConnection proxy); @Override boolean isAutoCommitSupported(); @Override boolean isAutoCommit(); @Override void setAutoCommit(boolean autoCommit); @Override Savepoint setSavePoint(String name); @Override void commit(Savepoint savePoint); @Override void rollback(Savepoint savePoint); @Override int executeStatement(String statementStr, int resultFlags); @Override CompiledStatement compileStatement(String statement, StatementType type, FieldType[] argFieldTypes,
int resultFlags, boolean cacheStore); @Override int insert(String statement, Object[] args, FieldType[] argfieldTypes, GeneratedKeyHolder keyHolder); @Override int update(String statement, Object[] args, FieldType[] argfieldTypes); @Override int delete(String statement, Object[] args, FieldType[] argfieldTypes); @Override Object queryForOne(String statement, Object[] args, FieldType[] argfieldTypes,
GenericRowMapper<T> rowMapper, ObjectCache objectCache); @Override long queryForLong(String statement); @Override long queryForLong(String statement, Object[] args, FieldType[] argFieldTypes); @Override void close(); @Override void closeQuietly(); @Override boolean isClosed(); @Override boolean isTableExists(String tableName); }### Answer:
@Test public void testIsAutoCommitSupported() throws Exception { DatabaseConnection conn = createMock(DatabaseConnection.class); boolean supported = true; expect(conn.isAutoCommitSupported()).andReturn(supported); conn.close(); DatabaseConnectionProxy proxy = new DatabaseConnectionProxy(conn); replay(conn); assertEquals(supported, proxy.isAutoCommitSupported()); proxy.close(); verify(conn); } |
### Question:
DefaultParameterContext implements ParameterContext { @Override @Nullable public BindingParameter tryExpandBindingParameter(BindingParameter bindingParameter) { if (!nameToTypeMap.containsKey(bindingParameter.getParameterName())) { BindingParameter newBindingParameter = bindingParameter.rightShift(); List<String> parameterNames = new ArrayList<String>(); for (Map.Entry<String, Type> entry : nameToTypeMap.entrySet()) { Type type = entry.getValue(); try { FunctionalBindingParameterInvoker.create(type, newBindingParameter); } catch (BindingException e) { continue; } parameterNames.add(entry.getKey()); } int num = parameterNames.size(); if (num > 0) { if (num != 1) { throw new BindingException("Root parameters " + transToBindingParameters(parameterNames) + " has the same property '" + newBindingParameter.getPropertyPath() + "', so can't auto expand"); } return BindingParameter.create( parameterNames.get(0), newBindingParameter.getPropertyPath(), newBindingParameter.getJdbcType()); } } return null; } private DefaultParameterContext(List<ParameterDescriptor> parameterDescriptors); static DefaultParameterContext create(List<ParameterDescriptor> parameterDescriptors); @Override String getParameterNameByPosition(int position); @Override BindingParameterInvoker getBindingParameterInvoker(BindingParameter bindingParameter); @Override List<ParameterDescriptor> getParameterDescriptors(); @Override @Nullable BindingParameter tryExpandBindingParameter(BindingParameter bindingParameter); }### Answer:
@Test public void testTryExpandBindingParameter() throws Exception { List<Annotation> empty = Collections.emptyList(); ParameterDescriptor p0 = ParameterDescriptor.create(0, String.class, empty, "1"); ParameterDescriptor p1 = ParameterDescriptor.create(1, User.class, empty, "2"); List<ParameterDescriptor> pds = Arrays.asList(p0, p1); ParameterContext ctx = DefaultParameterContext.create(pds); BindingParameter bp = BindingParameter.create("userBag", "item.itemId", null); BindingParameter nbp = ctx.tryExpandBindingParameter(bp); assertThat(nbp, equalTo(BindingParameter.create("2", "userBag.item.itemId", null))); bp = BindingParameter.create("userId", "", null); nbp = ctx.tryExpandBindingParameter(bp); assertThat(nbp, equalTo(BindingParameter.create("2", "userId", null))); bp = BindingParameter.create("userIds", "", null); nbp = ctx.tryExpandBindingParameter(bp); assertThat(nbp, nullValue()); } |
### Question:
DatabaseConnectionProxy implements DatabaseConnection { @Override public boolean isAutoCommit() throws SQLException { if (proxy == null) { return false; } else { return proxy.isAutoCommit(); } } DatabaseConnectionProxy(DatabaseConnection proxy); @Override boolean isAutoCommitSupported(); @Override boolean isAutoCommit(); @Override void setAutoCommit(boolean autoCommit); @Override Savepoint setSavePoint(String name); @Override void commit(Savepoint savePoint); @Override void rollback(Savepoint savePoint); @Override int executeStatement(String statementStr, int resultFlags); @Override CompiledStatement compileStatement(String statement, StatementType type, FieldType[] argFieldTypes,
int resultFlags, boolean cacheStore); @Override int insert(String statement, Object[] args, FieldType[] argfieldTypes, GeneratedKeyHolder keyHolder); @Override int update(String statement, Object[] args, FieldType[] argfieldTypes); @Override int delete(String statement, Object[] args, FieldType[] argfieldTypes); @Override Object queryForOne(String statement, Object[] args, FieldType[] argfieldTypes,
GenericRowMapper<T> rowMapper, ObjectCache objectCache); @Override long queryForLong(String statement); @Override long queryForLong(String statement, Object[] args, FieldType[] argFieldTypes); @Override void close(); @Override void closeQuietly(); @Override boolean isClosed(); @Override boolean isTableExists(String tableName); }### Answer:
@Test public void testIsAutoCommit() throws Exception { DatabaseConnection conn = createMock(DatabaseConnection.class); boolean autoCommit = false; expect(conn.isAutoCommit()).andReturn(autoCommit); conn.close(); DatabaseConnectionProxy proxy = new DatabaseConnectionProxy(conn); replay(conn); assertEquals(autoCommit, proxy.isAutoCommit()); proxy.close(); verify(conn); } |
### Question:
DatabaseConnectionProxy implements DatabaseConnection { @Override public void setAutoCommit(boolean autoCommit) throws SQLException { if (proxy != null) { proxy.setAutoCommit(autoCommit); } } DatabaseConnectionProxy(DatabaseConnection proxy); @Override boolean isAutoCommitSupported(); @Override boolean isAutoCommit(); @Override void setAutoCommit(boolean autoCommit); @Override Savepoint setSavePoint(String name); @Override void commit(Savepoint savePoint); @Override void rollback(Savepoint savePoint); @Override int executeStatement(String statementStr, int resultFlags); @Override CompiledStatement compileStatement(String statement, StatementType type, FieldType[] argFieldTypes,
int resultFlags, boolean cacheStore); @Override int insert(String statement, Object[] args, FieldType[] argfieldTypes, GeneratedKeyHolder keyHolder); @Override int update(String statement, Object[] args, FieldType[] argfieldTypes); @Override int delete(String statement, Object[] args, FieldType[] argfieldTypes); @Override Object queryForOne(String statement, Object[] args, FieldType[] argfieldTypes,
GenericRowMapper<T> rowMapper, ObjectCache objectCache); @Override long queryForLong(String statement); @Override long queryForLong(String statement, Object[] args, FieldType[] argFieldTypes); @Override void close(); @Override void closeQuietly(); @Override boolean isClosed(); @Override boolean isTableExists(String tableName); }### Answer:
@Test public void testSetAutoCommit() throws Exception { DatabaseConnection conn = createMock(DatabaseConnection.class); boolean autoCommit = false; conn.setAutoCommit(autoCommit); conn.close(); DatabaseConnectionProxy proxy = new DatabaseConnectionProxy(conn); replay(conn); proxy.setAutoCommit(autoCommit); proxy.close(); verify(conn); } |
### Question:
DatabaseConnectionProxy implements DatabaseConnection { @Override public Savepoint setSavePoint(String name) throws SQLException { if (proxy == null) { return null; } else { return proxy.setSavePoint(name); } } DatabaseConnectionProxy(DatabaseConnection proxy); @Override boolean isAutoCommitSupported(); @Override boolean isAutoCommit(); @Override void setAutoCommit(boolean autoCommit); @Override Savepoint setSavePoint(String name); @Override void commit(Savepoint savePoint); @Override void rollback(Savepoint savePoint); @Override int executeStatement(String statementStr, int resultFlags); @Override CompiledStatement compileStatement(String statement, StatementType type, FieldType[] argFieldTypes,
int resultFlags, boolean cacheStore); @Override int insert(String statement, Object[] args, FieldType[] argfieldTypes, GeneratedKeyHolder keyHolder); @Override int update(String statement, Object[] args, FieldType[] argfieldTypes); @Override int delete(String statement, Object[] args, FieldType[] argfieldTypes); @Override Object queryForOne(String statement, Object[] args, FieldType[] argfieldTypes,
GenericRowMapper<T> rowMapper, ObjectCache objectCache); @Override long queryForLong(String statement); @Override long queryForLong(String statement, Object[] args, FieldType[] argFieldTypes); @Override void close(); @Override void closeQuietly(); @Override boolean isClosed(); @Override boolean isTableExists(String tableName); }### Answer:
@Test public void testSetSavePoint() throws Exception { DatabaseConnection conn = createMock(DatabaseConnection.class); String name = "savepoint"; expect(conn.setSavePoint(name)).andReturn(null); conn.close(); DatabaseConnectionProxy proxy = new DatabaseConnectionProxy(conn); replay(conn); proxy.setSavePoint(name); proxy.close(); verify(conn); } |
### Question:
DatabaseConnectionProxy implements DatabaseConnection { @Override public void commit(Savepoint savePoint) throws SQLException { if (proxy != null) { proxy.commit(savePoint); } } DatabaseConnectionProxy(DatabaseConnection proxy); @Override boolean isAutoCommitSupported(); @Override boolean isAutoCommit(); @Override void setAutoCommit(boolean autoCommit); @Override Savepoint setSavePoint(String name); @Override void commit(Savepoint savePoint); @Override void rollback(Savepoint savePoint); @Override int executeStatement(String statementStr, int resultFlags); @Override CompiledStatement compileStatement(String statement, StatementType type, FieldType[] argFieldTypes,
int resultFlags, boolean cacheStore); @Override int insert(String statement, Object[] args, FieldType[] argfieldTypes, GeneratedKeyHolder keyHolder); @Override int update(String statement, Object[] args, FieldType[] argfieldTypes); @Override int delete(String statement, Object[] args, FieldType[] argfieldTypes); @Override Object queryForOne(String statement, Object[] args, FieldType[] argfieldTypes,
GenericRowMapper<T> rowMapper, ObjectCache objectCache); @Override long queryForLong(String statement); @Override long queryForLong(String statement, Object[] args, FieldType[] argFieldTypes); @Override void close(); @Override void closeQuietly(); @Override boolean isClosed(); @Override boolean isTableExists(String tableName); }### Answer:
@Test public void testCommit() throws Exception { DatabaseConnection conn = createMock(DatabaseConnection.class); conn.commit(null); conn.close(); DatabaseConnectionProxy proxy = new DatabaseConnectionProxy(conn); replay(conn); proxy.commit(null); proxy.close(); verify(conn); } |
### Question:
DatabaseConnectionProxy implements DatabaseConnection { @Override public void rollback(Savepoint savePoint) throws SQLException { if (proxy != null) { proxy.rollback(savePoint); } } DatabaseConnectionProxy(DatabaseConnection proxy); @Override boolean isAutoCommitSupported(); @Override boolean isAutoCommit(); @Override void setAutoCommit(boolean autoCommit); @Override Savepoint setSavePoint(String name); @Override void commit(Savepoint savePoint); @Override void rollback(Savepoint savePoint); @Override int executeStatement(String statementStr, int resultFlags); @Override CompiledStatement compileStatement(String statement, StatementType type, FieldType[] argFieldTypes,
int resultFlags, boolean cacheStore); @Override int insert(String statement, Object[] args, FieldType[] argfieldTypes, GeneratedKeyHolder keyHolder); @Override int update(String statement, Object[] args, FieldType[] argfieldTypes); @Override int delete(String statement, Object[] args, FieldType[] argfieldTypes); @Override Object queryForOne(String statement, Object[] args, FieldType[] argfieldTypes,
GenericRowMapper<T> rowMapper, ObjectCache objectCache); @Override long queryForLong(String statement); @Override long queryForLong(String statement, Object[] args, FieldType[] argFieldTypes); @Override void close(); @Override void closeQuietly(); @Override boolean isClosed(); @Override boolean isTableExists(String tableName); }### Answer:
@Test public void testRollback() throws Exception { DatabaseConnection conn = createMock(DatabaseConnection.class); conn.rollback(null); conn.close(); DatabaseConnectionProxy proxy = new DatabaseConnectionProxy(conn); replay(conn); proxy.rollback(null); proxy.close(); verify(conn); } |
### Question:
DatabaseConnectionProxy implements DatabaseConnection { @Override public int insert(String statement, Object[] args, FieldType[] argfieldTypes, GeneratedKeyHolder keyHolder) throws SQLException { if (proxy == null) { return 0; } else { return proxy.insert(statement, args, argfieldTypes, keyHolder); } } DatabaseConnectionProxy(DatabaseConnection proxy); @Override boolean isAutoCommitSupported(); @Override boolean isAutoCommit(); @Override void setAutoCommit(boolean autoCommit); @Override Savepoint setSavePoint(String name); @Override void commit(Savepoint savePoint); @Override void rollback(Savepoint savePoint); @Override int executeStatement(String statementStr, int resultFlags); @Override CompiledStatement compileStatement(String statement, StatementType type, FieldType[] argFieldTypes,
int resultFlags, boolean cacheStore); @Override int insert(String statement, Object[] args, FieldType[] argfieldTypes, GeneratedKeyHolder keyHolder); @Override int update(String statement, Object[] args, FieldType[] argfieldTypes); @Override int delete(String statement, Object[] args, FieldType[] argfieldTypes); @Override Object queryForOne(String statement, Object[] args, FieldType[] argfieldTypes,
GenericRowMapper<T> rowMapper, ObjectCache objectCache); @Override long queryForLong(String statement); @Override long queryForLong(String statement, Object[] args, FieldType[] argFieldTypes); @Override void close(); @Override void closeQuietly(); @Override boolean isClosed(); @Override boolean isTableExists(String tableName); }### Answer:
@Test public void testInsert() throws Exception { DatabaseConnection conn = createMock(DatabaseConnection.class); String statement = "insert bar"; int result = 13712321; expect(conn.insert(statement, null, null, null)).andReturn(result); conn.close(); DatabaseConnectionProxy proxy = new DatabaseConnectionProxy(conn); replay(conn); assertEquals(result, proxy.insert(statement, null, null, null)); proxy.close(); verify(conn); } |
Subsets and Splits
No saved queries yet
Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.