auphong2707/dl4se-code-review-dataset huggingface dataset:
Source:
public PersistedData serializeNonNull(T value, PersistedDataSerializer serializer) { if (typeInfo.getRawType().isPrimitive()) { if (delegateHandler != null) { return delegateHandler.serialize(value, serializer); } return null; } TypeHandler<T> chosenHandler = delegateHandler; Class<?> runtimeClass = getRuntimeTypeIfMoreSpecific(typeInfo, value); if (!typeInfo.getRawType().equals(runtimeClass)) { TypeHandler<T> runtimeTypeHandler = (TypeHandler<T>) typeSerializationLibrary.getTypeHandler(runtimeClass); if (delegateHandler == null) { chosenHandler = runtimeTypeHandler; } else if (runtimeTypeHandler.getClass().equals(delegateHandler.getClass())) { chosenHandler = delegateHandler; } else if (!(runtimeTypeHandler instanceof ObjectFieldMapTypeHandler)) { chosenHandler = runtimeTypeHandler; } else if (!(delegateHandler instanceof ObjectFieldMapTypeHandler)) { chosenHandler = delegateHandler; } else { chosenHandler = runtimeTypeHandler; } } if (chosenHandler == delegateHandler) { return delegateHandler.serialize(value, serializer); } Map<String, PersistedData> typeValuePersistedDataMap = Maps.newLinkedHashMap(); typeValuePersistedDataMap.put( TYPE_FIELD, serializer.serialize(runtimeClass.getName()) ); typeValuePersistedDataMap.put( VALUE_FIELD, chosenHandler.serialize(value, serializer) ); return serializer.serialize(typeValuePersistedDataMap); }

Target:
public PersistedData serializeNonNull(T value, PersistedDataSerializer serializer) { if (typeInfo.getRawType().isPrimitive()) { return delegateHandler.serialize(value, serializer); } TypeHandler<T> chosenHandler = delegateHandler; Class<?> runtimeClass = getRuntimeTypeIfMoreSpecific(typeInfo, value); if (!typeInfo.getRawType().equals(runtimeClass)) { TypeHandler<T> runtimeTypeHandler = (TypeHandler<T>) typeSerializationLibrary.getTypeHandler(runtimeClass); if (delegateHandler == null) { chosenHandler = runtimeTypeHandler; } else if (runtimeTypeHandler.getClass().equals(delegateHandler.getClass())) { chosenHandler = delegateHandler; } else if (!(runtimeTypeHandler instanceof ObjectFieldMapTypeHandler)) { chosenHandler = runtimeTypeHandler; } else if (!(delegateHandler instanceof ObjectFieldMapTypeHandler)) { chosenHandler = delegateHandler; } else { chosenHandler = runtimeTypeHandler; } } if (chosenHandler == delegateHandler) { return delegateHandler.serialize(value, serializer); } Map<String, PersistedData> typeValuePersistedDataMap = Maps.newLinkedHashMap(); typeValuePersistedDataMap.put( TYPE_FIELD, serializer.serialize(runtimeClass.getName()) ); typeValuePersistedDataMap.put( VALUE_FIELD, chosenHandler.serialize(value, serializer) ); return serializer.serialize(typeValuePersistedDataMap); }
Source:
private List<File> getPluginFiles() throws IOException { if (pluginsDir == null || !pluginsDir.exists()) { return Collections.emptyList(); } return Arrays.asList(pluginsDir.listFiles(new FileFilter() { @Override public boolean accept(File pathname) { return pathname.getName().endsWith(".jar"); } })); }

Target:
private List<File> getPluginFiles() throws IOException { if (pluginsDir == null || !pluginsDir.exists()) { return Collections.emptyList(); } File[] plugins = pluginsDir.listFiles(new FileFilter() { @Override public boolean accept(File pathname) { return pathname.isFile() && pathname.getName().endsWith(".jar"); } }); if (plugins == null) { log.warn("Cannot list " + pluginsDir.getAbsolutePath()); return Collections.emptyList(); } return Arrays.asList(plugins); }
Source:
public ImageGenerator() { imageWidth = 200; imageHeight = 200; imageBuffer = new BufferedImage(imageWidth, imageHeight, BufferedImage.TYPE_INT_ARGB); }

Target:
public ImageGenerator() { imageBuffer = new BufferedImage(imageWidth, imageHeight, BufferedImage.TYPE_INT_ARGB); }
Source:
public static Map<String, String> getExecutionInfo(Rule rule, boolean allowTagsPropagation) { if (allowTagsPropagation){ return getExecutionInfo(rule); } else { return Collections.emptyMap(); } }

Target:
public static ImmutableMap<String, String> getExecutionInfo(Rule rule, boolean allowTagsPropagation) { if (allowTagsPropagation) { return ImmutableMap.copyOf(getExecutionInfo(rule)); } else { return ImmutableMap.of(); } }
Source:
public void init() { post( "/list/import", (request, response) -> { MultipartConfigElement multipartConfigElement = new MultipartConfigElement(""); request.raw().setAttribute("org.eclipse.jetty.multipartConfig", multipartConfigElement); String listType = request.headers(LIST_TYPE_HEADER); if (StringUtils.isBlank(listType)) { String exceptionMessage = String.format("The header %s must be set.", LIST_TYPE_HEADER); LOGGER.info(exceptionMessage); createBadRequestResponse(exceptionMessage, response); return null; } List<Part> parts = new ArrayList<>(request.raw().getParts()); CreateInfo createInfo = parseAttachments(parts); if (createInfo == null) { String exceptionMessage = "Unable to parse the attachments."; LOGGER.info(exceptionMessage); createBadRequestResponse(exceptionMessage, response); return null; } for (Splitter splitter : lookupSplitter(createInfo.contentType)) { List<String> ids = new LinkedList<>(); List<String> errorMessages = new LinkedList<>(); boolean isSplitSuccessful = false; try (Stream<StorableResource> stream = createStream(createInfo, splitter)) { isSplitSuccessful = true; stream .sequential() .peek(storableResource -> appendMessageIfError(errorMessages, storableResource)) .filter(storableResource -> !storableResource.isError()) .forEach( storableResource -> storeAndClose(ids::add, errorMessages::add, storableResource)); } catch (IOException e) { LOGGER.debug("Failed to split the incoming data. Trying the next splitter.", e); } if (isSplitSuccessful) { errorMessages.forEach( s -> LOGGER.debug(String.format("Unable to ingest split item: %s", s))); response.header("Added-IDs", ids.stream().collect(Collectors.joining(","))); break; } } IOUtils.closeQuietly(createInfo.getStream()); return ""; }); }

Target:
public void init() { post( "/list/import", (request, response) -> { MultipartConfigElement multipartConfigElement = new MultipartConfigElement(""); request.raw().setAttribute("org.eclipse.jetty.multipartConfig", multipartConfigElement); String listType = request.headers(LIST_TYPE_HEADER); if (StringUtils.isBlank(listType)) { String exceptionMessage = String.format("The header %s must be set.", LIST_TYPE_HEADER); LOGGER.info(exceptionMessage); createBadRequestResponse(exceptionMessage, response); return null; } List<Part> parts = new ArrayList<>(request.raw().getParts()); AttachmentInfo attachmentInfo = parseAttachments(parts); if (attachmentInfo == null) { String exceptionMessage = "Unable to parse the attachments."; LOGGER.debug(exceptionMessage); createBadRequestResponse(exceptionMessage, response); return null; } try (TemporaryFileBackedOutputStream temporaryFileBackedOutputStream = new TemporaryFileBackedOutputStream()) { IOUtils.copy(attachmentInfo.getStream(), temporaryFileBackedOutputStream); for (Splitter splitter : lookupSplitters(attachmentInfo.getContentType())) { if (attemptToSplitAndStore( response, listType, attachmentInfo, temporaryFileBackedOutputStream, splitter)) break; } } IOUtils.closeQuietly(attachmentInfo.getStream()); return ""; }); }
Source:
public void testBadNumberOfArguments() throws HiveException { ObjectInspector value1 = PrimitiveObjectInspectorFactory.javaStringObjectInspector; ObjectInspector value2 = PrimitiveObjectInspectorFactory.javaStringObjectInspector; ObjectInspector[] initArguments = new ObjectInspector[]{value1,value2}; UAParserUDF uaParserUDF = new UAParserUDF(); uaParserUDF.initialize(initArguments); ObjectInspector value3 = PrimitiveObjectInspectorFactory.javaIntObjectInspector; initArguments = new ObjectInspector[]{value3}; uaParserUDF.initialize(initArguments); }

Target:
public void testBadNumberOfArguments() throws HiveException { ObjectInspector value1 = PrimitiveObjectInspectorFactory.javaStringObjectInspector; ObjectInspector value2 = PrimitiveObjectInspectorFactory.javaStringObjectInspector; ObjectInspector[] initArguments = new ObjectInspector[]{value1, value2}; UAParserUDF uaParserUDF = new UAParserUDF(); uaParserUDF.initialize(initArguments); }
Source:
public static void main(String[] args) { try { LoggingFactory.init("INFO"); MapperInterface mapper = new MapperLinear(-1, 1, -1, 1); log.info("mapper {}", mapper); double result = mapper.calcOutput(0.5); log.info("{}", result); } catch (Exception e) { log.error("main threw", e); } }

Target:
public static void main(String[] args) { try { LoggingFactory.init("INFO"); Mapper mapper = new MapperLinear(); mapper.map(-1.0, 1.0, -1.0, 1.0); log.info("mapper {}", mapper); double result = mapper.calcOutput(0.5); log.info("{}", result); } catch (Exception e) { log.error("main threw", e); } }
Source:
public boolean isAnnotatedOverride() { for (AnnotationTree annotationTree : modifiers.annotations()) { if (annotationTree.annotationType().is(Tree.Kind.IDENTIFIER) && isOverride((IdentifierTree) annotationTree.annotationType())) { return true; } else if (annotationTree.annotationType().is(Kind.MEMBER_SELECT)) { MemberSelectExpressionTree mse = (MemberSelectExpressionTree) annotationTree.annotationType(); if(isOverride(mse.identifier()) && mse.expression().is(Kind.MEMBER_SELECT)) { mse = (MemberSelectExpressionTree) mse.expression(); return "lang".equals(mse.identifier().name()) && mse.expression().is(Kind.IDENTIFIER) && "java".equals(((IdentifierTree) mse.expression()).name()); } } } return false; }

Target:
public boolean isAnnotatedOverride() { for (AnnotationTree annotationTree : modifiers.annotations()) { if (isJavaLangOverride(annotationTree.annotationType())) { return true; } } return false; }
Source:
public NumericColumnSelector makeMathExpressionSelector(String expression) { final Expr parsed = Parser.parse(expression); final Set<String> required = Sets.newHashSet(Parser.findRequiredBindings(parsed)); final Map<String, Supplier<Number>> values = Maps.newHashMapWithExpectedSize(required.size()); for (final String columnName : required) { values.put( columnName, new Supplier<Number>() { @Override public Number get() { return row.get().getFloatMetric(columnName); } } ); } final Expr.ObjectBinding binding = Parser.withSuppliers(values); return new NumericColumnSelector() { @Override public Number get() { return parsed.eval(binding); } }; }

Target:
public NumericColumnSelector makeMathExpressionSelector(String expression) { final Expr parsed = Parser.parse(expression); final List<String> required = Parser.findRequiredBindings(parsed); final Map<String, Supplier<Number>> values = Maps.newHashMapWithExpectedSize(required.size()); for (final String columnName : required) { values.put( columnName, new Supplier<Number>() { @Override public Number get() { return Evals.toNumber(row.get().getRaw(columnName)); } } ); } final Expr.ObjectBinding binding = Parser.withSuppliers(values); return new NumericColumnSelector() { @Override public Number get() { return parsed.eval(binding); } }; }
Source:
public HookResult onMessage(SMTPSession session, Mail mail) { LOGGER.debug("sending mail"); try { queue.enQueue(mail); Collection<MailAddress> theRecipients = mail.getRecipients(); String recipientString = ""; if (theRecipients != null) { recipientString = theRecipients.toString(); } if (LOGGER.isInfoEnabled()) { LOGGER.info("Successfully spooled mail " + mail.getName() + " from " + mail.getSender() + " on " + session.getRemoteAddress().getAddress().toString() + " for " + recipientString); } } catch (MessagingException me) { LOGGER.error("Unknown error occurred while processing DATA.", me); return new HookResult(HookReturnCode.DENYSOFT, DSNStatus.getStatus(DSNStatus.TRANSIENT, DSNStatus.UNDEFINED_STATUS) + " Error processing message."); } return new HookResult(HookReturnCode.OK, DSNStatus.getStatus(DSNStatus.SUCCESS, DSNStatus.CONTENT_OTHER) + " Message received"); }

Target:
public HookResult onMessage(SMTPSession session, Mail mail) { LOGGER.debug("sending mail"); try { queue.enQueue(mail); LOGGER.info("Successfully spooled mail from on for {}", mail.getName(), mail.getSender(), session.getRemoteAddress().getAddress(), mail.getRecipients()); } catch (MessagingException me) { LOGGER.error("Unknown error occurred while processing DATA.", me); return new HookResult(HookReturnCode.DENYSOFT, DSNStatus.getStatus(DSNStatus.TRANSIENT, DSNStatus.UNDEFINED_STATUS) + " Error processing message."); } return new HookResult(HookReturnCode.OK, DSNStatus.getStatus(DSNStatus.SUCCESS, DSNStatus.CONTENT_OTHER) + " Message received"); }
Source:
protected void populateColumnSchema(ArrayList<VoltTable.ColumnInfo> columns) { super.populateColumnSchema(columns); columns.add(new ColumnInfo(Columns.CONSUMER_CLUSTER_ID, VoltType.INTEGER)); columns.add(new ColumnInfo(Columns.STATE, VoltType.STRING)); columns.add(new ColumnInfo(Columns.SYNC_SNAPSHOT_STATE, VoltType.STRING)); columns.add(new ColumnInfo(Columns.ROWS_IN_SYNC_SNAPSHOT, VoltType.BIGINT)); columns.add(new ColumnInfo(Columns.ROWS_ACKED_FOR_SYNC_SNAPSHOT, VoltType.BIGINT)); columns.add(new ColumnInfo(Columns.QUEUE_DEPTH, VoltType.BIGINT)); }

Target:
protected void populateColumnSchema(ArrayList<VoltTable.ColumnInfo> columns) { super.populateColumnSchema(columns); if (m_addConsumerIdStat) { columns.add(new ColumnInfo(Columns.CONSUMER_CLUSTER_ID, VoltType.SMALLINT)); } columns.add(new ColumnInfo(Columns.STATE, VoltType.STRING)); columns.add(new ColumnInfo(Columns.SYNC_SNAPSHOT_STATE, VoltType.STRING)); columns.add(new ColumnInfo(Columns.ROWS_IN_SYNC_SNAPSHOT, VoltType.BIGINT)); columns.add(new ColumnInfo(Columns.ROWS_ACKED_FOR_SYNC_SNAPSHOT, VoltType.BIGINT)); columns.add(new ColumnInfo(Columns.QUEUE_DEPTH, VoltType.BIGINT)); }
Source:
protected Button getButton(int id) { return buttons.get(new Integer(id)); }

Target:
protected Button getButton(int id) { return buttons.get(id); }
Source:
private boolean isConstantFilterFunction(FilterFunction filter, Block[] constantBlocks) { return Arrays.stream(filter.getInputChannels()).allMatch(channel -> constantBlocks[channel] != null); }

Target:
private static boolean isConstantFilterFunction(FilterFunction filter, Block[] constantBlocks) { return Arrays.stream(filter.getInputChannels()).allMatch(channel -> constantBlocks[channel] != null); }
Source:
public static List<String> parseTopicsList(Map<String, String> props) { List<String> topics = (List<String>) ConfigDef.parseType(TOPICS_CONFIG, props.get(TOPICS_CONFIG), Type.LIST); return topics .stream() .filter(topic -> !topic.isEmpty()) .distinct() .collect(Collectors.toList()); }

Target:
public static List<String> parseTopicsList(Map<String, String> props) { List<String> topics = (List<String>) ConfigDef.parseType(TOPICS_CONFIG, props.get(TOPICS_CONFIG), Type.LIST); if (topics == null) { return Collections.emptyList(); } return topics .stream() .filter(topic -> !topic.isEmpty()) .distinct() .collect(Collectors.toList()); }
Source:
public String createString(final String key, final long value) { return createString(key, "" + value); }

Target:
public String createString(final String key, final long value) { return createString(key, String.valueOf(value)); }
Source:
public void saveOrUpdate( final D diagram, final ServiceCallback<D> callback ) { diagramServiceCaller.call( new RemoteCallback<M>() { @Override public void callback( M serverMetadata ) { AbstractClientDiagramService.this.updateClientMetadata( diagram ); diagram.getMetadata().setPath( serverMetadata.getPath() ); callback.onSuccess( diagram ); } }, ( message, throwable ) -> { callback.onError( new ClientRuntimeError( throwable ) ); return false; } ).saveOrUpdate( diagram ); }

Target:
public void saveOrUpdate( final D diagram, final ServiceCallback<D> callback ) { diagramServiceCaller.call( serverMetadata-> { AbstractClientDiagramService.this.updateClientMetadata( diagram ); diagram.getMetadata().setPath( ( (M) serverMetadata).getPath() ); callback.onSuccess( diagram ); }, ( message, throwable ) -> { callback.onError( new ClientRuntimeError( throwable ) ); return false; } ).saveOrUpdate( diagram ); }
Source:
protected void updatePoolProperties() { long maxDirectMemory = 64 * 1024 * 1024; try { if (UnderlyingSystemInfo.JVM_PROVIDER.equals(JvmProvider.SUN) || UnderlyingSystemInfo.JVM_PROVIDER.equals(JvmProvider.ORACLE) || UnderlyingSystemInfo.JVM_PROVIDER.equals(JvmProvider.AZUL)) { Class<?> vmClazz = Class.forName("sun.misc.VM"); Method directMemoryMethod = vmClazz.getMethod("maxDirectMemory"); directMemoryMethod.setAccessible(true); maxDirectMemory = (Long) directMemoryMethod.invoke(null); log.debug("Direct memory available for the JVM {}", maxDirectMemory); } } catch (Exception e) { if (log.isDebugEnabled()) { log.debug("Exception occurred trying to use the class sun.misc.VM via reflection", e); } } if (poolMinCapacity > (long) (maxDirectMemory * bufferPoolMinDirectMemoryOccupancy)) { poolMinCapacity = (long) (maxDirectMemory * bufferPoolMinDirectMemoryOccupancy); } if (poolMaxCapacity > (long) (maxDirectMemory * bufferPoolMaxDirectMemoryOccupancy)) { poolMaxCapacity = (long) (maxDirectMemory * bufferPoolMaxDirectMemoryOccupancy); } poolFactory.setBufferCapacity(bufferSize); int maxIdle = (int) (poolMinCapacity / bufferSize); int maxActive = (int) (poolMaxCapacity / bufferSize); super.setMaxIdle(maxIdle); super.setMaxActive(maxActive); log.info("|-Updated byte buffer pool capacity, maxIdle={} and maxActive={}", maxIdle, maxActive); log.info("|-Default byte buffer size set to {}", bufferSize); }

Target:
protected void updatePoolProperties() { long maxDirectMemory = 64 * 1024 * 1024; try { Class<?> vmClazz = Class.forName("sun.misc.VM"); Method directMemoryMethod = vmClazz.getMethod("maxDirectMemory"); directMemoryMethod.setAccessible(true); maxDirectMemory = (Long) directMemoryMethod.invoke(null); log.debug("Direct memory available for the JVM {}", maxDirectMemory); } catch (Exception e) { if (log.isDebugEnabled()) { log.debug("Exception occurred trying to use the class sun.misc.VM via reflection", e); } } if (poolMinCapacity > (long) (maxDirectMemory * bufferPoolMinDirectMemoryOccupancy)) { poolMinCapacity = (long) (maxDirectMemory * bufferPoolMinDirectMemoryOccupancy); } if (poolMaxCapacity > (long) (maxDirectMemory * bufferPoolMaxDirectMemoryOccupancy)) { poolMaxCapacity = (long) (maxDirectMemory * bufferPoolMaxDirectMemoryOccupancy); } poolFactory.setBufferCapacity(bufferSize); int maxIdle = (int) (poolMinCapacity / bufferSize); int maxActive = (int) (poolMaxCapacity / bufferSize); super.setMaxIdle(maxIdle); super.setMaxActive(maxActive); log.info("|-Updated byte buffer pool capacity, maxIdle={} and maxActive={}", maxIdle, maxActive); log.info("|-Default byte buffer size set to {}", bufferSize); }
Source:
public void run() { ITmfTrace pinnedTrace = fPinnedTrace; if (fNewInstance) { if (pinnedTrace == null) { return; } IFile file = TmfTraceManager.getInstance().getTraceContext(pinnedTrace).getEditorFile(); Object element = new TmfEditorLinkHelper().findSelection(new FileEditorInput(file)).getFirstElement(); if (element instanceof TmfCommonProjectElement) { OpenProjectElementThread openThread = new OpenProjectElementThread((TmfCommonProjectElement) element, file); openThread.start(); Thread waitThread = new Thread() { @Override public void run() { while (!TmfTraceManager.getInstance().getOpenedTraces().contains(openThread.getTrace())) { try { Thread.sleep(100); } catch (InterruptedException e) { return; } } Display.getDefault().asyncExec(() -> { IViewPart view = TmfViewFactory.newView(fViewId, true); if (view instanceof ITmfPinnable) { ((ITmfPinnable) view).setPinned(openThread.getTrace()); } }); } }; waitThread.start(); } return; } IViewPart view = TmfViewFactory.newView(fViewId, true); if (pinnedTrace != null && view instanceof ITmfPinnable) { ((ITmfPinnable) view).setPinned(pinnedTrace); } }

Target:
public void run() { ITmfTrace pinnedTrace = fPinnedTrace; if (fNewInstance) { if (pinnedTrace == null) { return; } IFile file = TmfTraceManager.getInstance().getTraceContext(pinnedTrace).getEditorFile(); Object element = new TmfEditorLinkHelper().findSelection(new FileEditorInput(file)).getFirstElement(); if (element instanceof TmfCommonProjectElement) { OpenProjectElementJob openJob = new OpenProjectElementJob((TmfCommonProjectElement) element, file); openJob.schedule(); Thread waitThread = new Thread() { @Override public void run() { while (!TmfTraceManager.getInstance().getOpenedTraces().contains(openJob.getTrace())) { try { Thread.sleep(100); } catch (InterruptedException e) { return; } } Display.getDefault().asyncExec(() -> { IViewPart view = TmfViewFactory.newView(fViewId, true); if (view instanceof ITmfPinnable) { ((ITmfPinnable) view).setPinned(openJob.getTrace()); } }); } }; waitThread.start(); } return; } IViewPart view = TmfViewFactory.newView(fViewId, true); if (pinnedTrace != null && view instanceof ITmfPinnable) { ((ITmfPinnable) view).setPinned(pinnedTrace); } }
Source:
private synchronized CswSubscription deleteCswSubscription(String subscriptionId) throws CswException { String methodName = "deleteCswSubscription"; LogSanitizer logSanitizedId = LogSanitizer.cleanAndEncode(subscriptionId); LOGGER.trace("ENTERING: {}", methodName); LOGGER.trace("subscriptionId = {}", LogSanitizer.cleanAndEncode(subscriptionId)); if (StringUtils.isEmpty(subscriptionId)) { throw new CswException( "Unable to delete subscription because subscription ID is null or empty"); } CswSubscription subscription = getSubscription(subscriptionId); try { LOGGER.debug("Removing (unregistering) subscription: {}", logSanitizedId); ServiceRegistration sr = registeredSubscriptions.remove(subscriptionId); if (sr != null) { sr.unregister(); } else { LOGGER.debug("No ServiceRegistration found for subscription: {}", logSanitizedId); } Configuration subscriptionConfig = getSubscriptionConfiguration(subscriptionId); try { if (subscriptionConfig != null) { LOGGER.debug("Deleting subscription for subscriptionId = {}", logSanitizedId); subscriptionConfig.delete(); } else { LOGGER.debug("subscriptionConfig is NULL for ID = {}", logSanitizedId); } } catch (IOException e) { LOGGER.debug( "IOException trying to delete subscription's configuration for subscription ID {}", subscriptionId, e); } LOGGER.debug("Subscription removal complete"); } catch (Exception e) { LOGGER.debug("Could not delete subscription for {}", logSanitizedId, e); } LOGGER.trace("EXITING: (status = {})", methodName, false); return subscription; }

Target:
private synchronized CswSubscription deleteCswSubscription(String subscriptionId) throws CswException { String methodName = "deleteCswSubscription"; LogSanitizer logSanitizedId = LogSanitizer.sanitize(subscriptionId); LOGGER.trace("ENTERING: {}", methodName); LOGGER.trace("subscriptionId = {}", logSanitizedId); if (StringUtils.isEmpty(subscriptionId)) { throw new CswException( "Unable to delete subscription because subscription ID is null or empty"); } CswSubscription subscription = getSubscription(subscriptionId); try { LOGGER.debug("Removing (unregistering) subscription: {}", logSanitizedId); ServiceRegistration sr = registeredSubscriptions.remove(subscriptionId); if (sr != null) { sr.unregister(); } else { LOGGER.debug("No ServiceRegistration found for subscription: {}", logSanitizedId); } Configuration subscriptionConfig = getSubscriptionConfiguration(subscriptionId); try { if (subscriptionConfig != null) { LOGGER.debug("Deleting subscription for subscriptionId = {}", logSanitizedId); subscriptionConfig.delete(); } else { LOGGER.debug("subscriptionConfig is NULL for ID = {}", logSanitizedId); } } catch (IOException e) { LOGGER.debug( "IOException trying to delete subscription's configuration for subscription ID {}", subscriptionId, e); } LOGGER.debug("Subscription removal complete"); } catch (Exception e) { LOGGER.debug("Could not delete subscription for {}", logSanitizedId, e); } LOGGER.trace("EXITING: (status = {})", methodName, false); return subscription; }
Source:
public void processCommands(String aQuery) { GerritUi.Ftracer.traceInfo("Process command : " + aQuery ); String lastSaved = fServerUtil.getLastSavedGerritServer(); if (lastSaved != null) { fTaskRepository = fServerUtil.getTaskRepo(lastSaved); } if (fTaskRepository == null) { fMapRepoServer = GerritServerUtility.getInstance().getGerritMapping(); if (fMapRepoServer.size() == 1) { Set<TaskRepository> mapSet = fMapRepoServer.keySet(); for (TaskRepository key: mapSet) { fTaskRepository = key; fServerUtil.saveLastGerritServer(key.getRepositoryUrl()); break; } } } if (fTaskRepository == null) { GerritUi.Ftracer.traceInfo(MESSAGE ); UIUtils.showErrorDialog(MESSAGE, REASON); } else { if (aQuery != null && !aQuery.equals("")) { updateTable (fTaskRepository, aQuery); } } }

Target:
public void processCommands(String aQuery) { GerritUi.Ftracer.traceInfo("Process command : " + aQuery ); String lastSaved = fServerUtil.getLastSavedGerritServer(); if (lastSaved != null) { fTaskRepository = fServerUtil.getTaskRepo(lastSaved); } if (fTaskRepository == null) { fMapRepoServer = GerritServerUtility.getInstance().getGerritMapping(); Set<TaskRepository> mapSet = fMapRepoServer.keySet(); if (fMapRepoServer.size() == 1) { for (TaskRepository key: mapSet) { fTaskRepository = key; fServerUtil.saveLastGerritServer(key.getRepositoryUrl()); break; } } else if (fMapRepoServer.size() > 1) { List<TaskRepository> listTaskRepository = new ArrayList<TaskRepository>(); for (TaskRepository key: mapSet) { listTaskRepository.add(key); } fTaskRepository = getSelectedRepositoryURL (listTaskRepository); if (fTaskRepository != null) { fServerUtil.saveLastGerritServer(fTaskRepository.getRepositoryUrl()); } } } if (fTaskRepository == null) { UIUtils.showErrorDialog("You need to define a Gerrit repository.", "No Gerrit repository has been selected yet."); } else { if (aQuery != null && !aQuery.equals("")) { updateTable (fTaskRepository, aQuery); } } }
Source:
public String getLogMessage() { return String.format("Processed integer %d", integerProgressStep.getInput()); }

Target:
public String getLogMessage() { return String.format("Entered concentration value: %d", integerProgressStep.getInput()); }
Source:
public void testConfirmFlag() { DispatchCallback callback = new DispatchCallback(); SqlLine line = new SqlLine(); assertEquals(Boolean.FALSE, line.getOpts().getConfirm()); line.runCommands( Collections.singletonList("!set confirm true"), callback); assertEquals(Boolean.TRUE, line.getOpts().getConfirm()); line.runCommands( Collections.singletonList("!set confirm false"), callback); assertEquals(Boolean.FALSE, line.getOpts().getConfirm()); }

Target:
public void testConfirmFlag() { try { DispatchCallback callback = new DispatchCallback(); SqlLine line = new SqlLine(); ByteArrayOutputStream os = new ByteArrayOutputStream(); assertEquals(Boolean.FALSE, line.getOpts().getConfirm()); begin(line, os, false, "-e", "!set confirm true"); assertEquals(Boolean.TRUE, line.getOpts().getConfirm()); begin(line, os, false, "-e", "!set confirm false"); assertEquals(Boolean.FALSE, line.getOpts().getConfirm()); } catch (Throwable e) { throw new RuntimeException(e); } }
Source:
public Map<Method, MessagingGatewaySupport> getGateways() { return Collections.unmodifiableMap(this.gatewayMap); }

Target:
public Map<Method, MessagingGatewaySupport> getGateways() { return Collections.<Method, MessagingGatewaySupport>unmodifiableMap(this.gatewayMap); }
Source:
public Transaction(final Integer id, final Integer userId, final Lot lot, final Date transactionDate, final Integer status, final Double quantity, final String comments, final Integer commitmentDate, final String sourceType, final Integer sourceId, final Integer sourceRecordId, final Double previousAmount, final Integer personId, final String inventoryID) { super(); this.id = id; this.userId = userId; this.lot = lot; this.transactionDate = transactionDate; this.status = status; this.quantity = quantity; this.comments = comments; this.commitmentDate = commitmentDate; this.sourceType = sourceType; this.sourceId = sourceId; this.sourceRecordId = sourceRecordId; this.previousAmount = previousAmount; this.personId = personId; this.lot.setStockId(inventoryID); }

Target:
public Transaction(final Integer id, final Integer userId, final Lot lot, final Date transactionDate, final Integer status, final Double quantity, final String comments, final Integer commitmentDate, final String sourceType, final Integer sourceId, final Integer sourceRecordId, final Double previousAmount, final Integer personId, final String inventoryID) { super(); this.id = id; this.userId = userId; this.lot = lot; this.transactionDate = transactionDate; this.status = status; this.quantity = quantity; this.comments = comments; this.commitmentDate = commitmentDate; this.sourceType = sourceType; this.sourceId = sourceId; this.sourceRecordId = sourceRecordId; this.previousAmount = previousAmount; this.personId = personId; if (this.lot != null) { this.lot.setStockId(inventoryID); } }
Source:
public void SignUp_validation2() { SignUpPageObject signUpPage = new SignUpPageObject(driver); signUpPage.openSignUpPage(); String userNameNotExisting = signUpPage.getTimeStamp(); signUpPage.typeInUserName(userNameNotExisting); String userNameEmail = Properties.emailQaart1; signUpPage.typeInEmail(userNameEmail); String passwordNotExisting = signUpPage.getTimeStamp(); signUpPage.typeInPassword(passwordNotExisting); signUpPage.selectToYoungBirthDate(); signUpPage.waitForTooYoungErrorMsg(); }

Target:
public void SignUp_validation2() { SignUpPageObject signUpPage = new SignUpPageObject(driver); signUpPage.openSignUpPage(); signUpPage.typeInUserName(signUpPage.getTimeStamp()); signUpPage.typeInEmail(Properties.emailQaart1); signUpPage.typeInPassword(signUpPage.getTimeStamp()); Calendar currentDate = Calendar.getInstance(); signUpPage.enterBirthDate( Integer.toString(currentDate.get(Calendar.MONTH) + 1), Integer.toString(currentDate.get(Calendar.DAY_OF_MONTH)), Integer.toString(currentDate.get(Calendar.YEAR)- PageContent.MIN_AGE) ); signUpPage.waitForTooYoungErrorMsg(); }
Source:
static public Expectation<List<OperationResult>> multiOp( final OvsdbClient client, DatabaseSchema dbs, final List<Table.OvsdbOperation> ops) { final Expectation<List<OperationResult>> result = new Expectation<>(); TransactionBuilder transaction = client.transactBuilder(dbs); for (Table.OvsdbOperation op: ops) { transaction.add(op.op); } FutureCallback<List<OperationResult>> cb = new FutureCallback<List<OperationResult>>() { @Override public void onSuccess(List<OperationResult> rlist) { OvsdbOpException exc = null; Integer idx = 0; for (OperationResult r: rlist) { if (exc == null && opResultHasError(r)) { exc = new OvsdbOpException(client, ops, idx, r); } idx++; } if (exc != null) result.failure(exc); else result.success(rlist); } @Override public void onFailure(@Nonnull Throwable exc) { result.failure(new OvsdbException(client, exc)); } }; Futures.addCallback(transaction.execute(), cb, callingThreadExecutor); return result; }

Target:
static public Expectation<List<OperationResult>> multiOp( final OvsdbClient client, DatabaseSchema dbs, final List<Table.OvsdbOperation> ops) { final Expectation<List<OperationResult>> result = new Expectation<>(); TransactionBuilder transaction = client.transactBuilder(dbs); for (Table.OvsdbOperation op: ops) { transaction.add(op.op); } FutureCallback<List<OperationResult>> cb = new FutureCallback<List<OperationResult>>() { @Override public void onSuccess(List<OperationResult> rlist) { OvsdbOpException exc = null; Integer idx = 0; for (OperationResult r: rlist) { if (opResultHasError(r)) { exc = new OvsdbOpException(client, ops, idx, r); break; } idx++; } if (exc != null) result.failure(exc); else result.success(rlist); } @Override public void onFailure(@Nonnull Throwable exc) { result.failure(new OvsdbException(client, exc)); } }; Futures.addCallback(transaction.execute(), cb, callingThreadExecutor); return result; }
Source:
public void changeEmailAddress() { final String newEmailAddress = "myAwesomeEmail@email.co.uk"; EditPreferencesPage editPrefPage = new EditPreferencesPage(driver).openEmailSection(); editPrefPage.changeEmail(newEmailAddress); PreferencesPageObject prefPage = editPrefPage.clickSaveButton(); prefPage.verifyNotificationMessage(); editPrefPage.openEmailSection(); Assertion.assertEquals(editPrefPage.getEmailAdress(), newEmailAddress); editPrefPage.changeEmail(Configuration.getCredentials().email); editPrefPage.clickSaveButton(); prefPage.verifyNotificationMessage(); editPrefPage.openEmailSection(); Assertion.assertEquals(editPrefPage.getEmailAdress(), Configuration.getCredentials().email); }

Target:
public void changeEmailAddress() { final String newEmailAddress = "myAwesomeEmail@email.co.uk"; final String oldEmailAddress = Configuration.getCredentials().email; EditPreferencesPage editPrefPage = new EditPreferencesPage(driver).openEmailSection(); editPrefPage.changeEmail(newEmailAddress); PreferencesPageObject prefPage = editPrefPage.clickSaveButton(); prefPage.verifyNotificationMessage(); editPrefPage.openEmailSection(); Assertion.assertEquals(editPrefPage.getEmailAdress(), newEmailAddress); editPrefPage.changeEmail(oldEmailAddress); editPrefPage.clickSaveButton(); prefPage.verifyNotificationMessage(); editPrefPage.openEmailSection(); Assertion.assertEquals(editPrefPage.getEmailAdress(), oldEmailAddress); }
Source:
public NewTableConfiguration enableSampling(SamplerConfiguration samplerConfiguration) { requireNonNull(samplerConfiguration); Map<String,String> tmp = new SamplerConfigurationImpl(samplerConfiguration).toTablePropertiesMap(); checkDisjoint(properties, tmp, summarizerProps); this.samplerProps = tmp; return this; }

Target:
public NewTableConfiguration enableSampling(SamplerConfiguration samplerConfiguration) { requireNonNull(samplerConfiguration); Map<String,String> tmp = new SamplerConfigurationImpl(samplerConfiguration).toTablePropertiesMap(); checkDisjoint(properties, tmp, "sampler"); this.samplerProps = tmp; return this; }
Source:
public String toString() { if (to == null || to.equals("")) { return ""; } else if (from == null || from.equals("")) { return to; } else if (readOnly == null || !readOnly) { if (noCopy == null || !noCopy) { return from + ":" + to; } else { return from + ":" + to + ":nocopy"; } } else { return from + ":" + to + ":ro"; } }

Target:
public String toString() { if (to == null || to.equals("")) { return ""; } else if (from == null || from.equals("")) { return to; } final String bind = from + ":" + to; final List<String> options = new ArrayList<>(); if (readOnly != null && readOnly) { options.add("ro"); } if (noCopy != null && noCopy) { options.add("nocopy"); } final String optionsValue = Joiner.on(',').join(options); return (optionsValue.isEmpty()) ? bind : bind + ":" + optionsValue; }
Source:
public boolean poll(Guid hostId) { waitBetweenPolls(); LOGGER.trace("Request to do poll for {}.", hostId); FutureVDSCall<VDSReturnValue> task = Backend.getInstance() .getResourceManager() .runFutureVdsCommand(FutureVDSCommandType.Poll, new VdsIdVDSCommandParametersBase(hostId)); LOGGER.trace("task executed."); boolean succeeded = getValue(task); LOGGER.trace("task result={}", succeeded); return succeeded; }

Target:
public boolean poll(Guid hostId) { waitBetweenPolls(); LOGGER.trace("Request to do poll for host {}.", hostId); FutureVDSCall<VDSReturnValue> task = Backend.getInstance() .getResourceManager() .runFutureVdsCommand(FutureVDSCommandType.Poll, new VdsIdVDSCommandParametersBase(hostId)); LOGGER.trace("FutureVDSCommandType.Poll executed for host{}.", hostId); boolean succeeded = getValue(task); LOGGER.trace("Result of FutureVDSCommandType.Poll for host {}: {}", hostId, succeeded); timestampOfEndOfPreviousInvocation = System.currentTimeMillis(); return succeeded; }
Source:
public void shouldFindConceptsBySourceUuid() throws Exception { SimpleObject response = deserialize(handle(newGetRequest(getURI(), new Parameter("uuid", "SSTRM-WGT234")))); List<Object> results = Util.getResultsList(response); Assert.assertEquals(results.size(), 1); Object next = results.iterator().next(); Assert.assertThat((String) PropertyUtils.getProperty(next, "uuid"), is("c607c80f-1ea9-4da3-bb88-6276ce8868dd")); }

Target:
public void shouldFindConceptsBySourceUuid() throws Exception { SimpleObject response = deserialize(handle(newGetRequest(getURI(), new Parameter("term", "SSTRM-WGT234")))); List<Object> results = Util.getResultsList(response); Assert.assertEquals(results.size(), 1); Object next = results.iterator().next(); Assert.assertThat((String) PropertyUtils.getProperty(next, "uuid"), is("c607c80f-1ea9-4da3-bb88-6276ce8868dd")); }
Source:
public static String getCassandraVersion() { if (isDSE()) { String cassandraVersion = dseToCassandraVersions.get(CASSANDRA_VERSION); if (cassandraVersion != null) { return cassandraVersion; } else if (CASSANDRA_VERSION.startsWith("3.") || CASSANDRA_VERSION.compareTo("3") <= 0) { return "1.2"; } else if (CASSANDRA_VERSION.startsWith("4.")) { if (CASSANDRA_VERSION.compareTo("4.7") >= 0) { return "2.0"; } else { return "2.1"; } } else { return "3.0"; } } else { return CASSANDRA_VERSION; } }

Target:
public static String getCassandraVersion() { if (isDSE()) { String cassandraVersion = dseToCassandraVersions.get(CASSANDRA_VERSION); if (cassandraVersion != null) { return cassandraVersion; } else if (CASSANDRA_VERSION.startsWith("3.") || CASSANDRA_VERSION.compareTo("3") <= 0) { return "1.2"; } else if (CASSANDRA_VERSION.startsWith("4.")) { if (CASSANDRA_VERSION.compareTo("4.7") >= 0) { return "2.1"; } else { return "2.0"; } } else { return "3.0"; } } else { return CASSANDRA_VERSION; } }
Source:
protected void parse() { if (isDone()) { MIOutput out = getMIOutput(); MIOOBRecord[] records = out.getMIOOBRecords(); StringBuilder builder = new StringBuilder(); for(MIOOBRecord rec : records) { if (rec instanceof MIConsoleStreamOutput) { MIStreamRecord o = (MIStreamRecord)rec; builder.append(o.getString()); } } fFullOutput = builder.toString(); fVersion = LaunchUtils.getGDBVersionFromText(fFullOutput); } }

Target:
protected void parse() { if (isDone()) { MIOutput out = getMIOutput(); MIOOBRecord[] records = out.getMIOOBRecords(); StringBuilder builder = new StringBuilder(); for(MIOOBRecord rec : records) { if (rec instanceof MIConsoleStreamOutput) { MIStreamRecord o = (MIStreamRecord)rec; builder.append(o.getString()); } } fFullOutput = builder.toString(); fVersion = parseVersion(fFullOutput); } }
Source:
private void testGetBlobWithVariousRanges(BlobInfo blobInfo) throws Exception { long blobSize = blobInfo.getBlobProperties().getBlobSize(); testGetBlob(blobInfo, null); testGetBlob(blobInfo, ByteRange.fromStartOffset(ThreadLocalRandom.current().nextLong(blobSize))); testGetBlob(blobInfo, ByteRange.fromLastNBytes(ThreadLocalRandom.current().nextLong(blobSize + 1))); long random1 = ThreadLocalRandom.current().nextLong(blobSize); long random2 = ThreadLocalRandom.current().nextLong(blobSize); testGetBlob(blobInfo, ByteRange.fromOffsetRange(Math.min(random1, random2), Math.max(random1, random2))); }

Target:
private void testGetBlobWithVariousRanges(BlobInfo blobInfo) throws Exception { long blobSize = blobInfo.getBlobProperties().getBlobSize(); testGetBlob(blobInfo, null); testGetBlob(blobInfo, ByteRange.fromLastNBytes(0)); if (blobSize > 0) { testGetBlob(blobInfo, ByteRange.fromStartOffset(0)); testGetBlob(blobInfo, ByteRange.fromStartOffset(ThreadLocalRandom.current().nextLong(1, blobSize - 1))); testGetBlob(blobInfo, ByteRange.fromStartOffset(blobSize - 1)); long random1 = ThreadLocalRandom.current().nextLong(blobSize); long random2 = ThreadLocalRandom.current().nextLong(blobSize); testGetBlob(blobInfo, ByteRange.fromOffsetRange(Math.min(random1, random2), Math.max(random1, random2))); testGetBlob(blobInfo, ByteRange.fromLastNBytes(blobSize)); } if (blobSize > 1) { testGetBlob(blobInfo, ByteRange.fromLastNBytes(ThreadLocalRandom.current().nextLong(1, blobSize))); } }
Source:
public Document getDocument(final String xml) throws ParserConfigurationException, SAXException, IOException { final DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance(); final DocumentBuilder builder = factory.newDocumentBuilder(); final InputSource is = new InputSource(); is.setCharacterStream(new StringReader(xml)); final Document doc = builder.parse(is); return doc; }

Target:
public Document getDocument(final String xml) throws ParserConfigurationException, SAXException, IOException { final DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance(); final DocumentBuilder builder = factory.newDocumentBuilder(); final InputSource is = new InputSource(); is.setCharacterStream(new StringReader(xml)); return builder.parse(is); }
Source:
private void checkError() { if (startAnchor.isPresent() && endAnchor.isPresent()) { try { endAnchor.get().getBlock().asExpr() .analyze(new Env(), new GenSet()); this.getStyleClass().remove("error"); } catch (HaskellTypeError e) { this.getStyleClass().add("error"); } catch (HaskellException e) { e.printStackTrace(); } } }

Target:
private void checkError() { if (startAnchor.isPresent() && endAnchor.isPresent()) { try { Block block = endAnchor.get().getBlock(); block.asExpr().analyze(new Env(), new GenSet()); this.getStyleClass().remove("error"); } catch (HaskellTypeError e) { this.getStyleClass().add("error"); } catch (HaskellException e) { e.printStackTrace(); } } }
Source:
private String toTimeString(long millis) { return String.format("%d min, %d sec", TimeUnit.MILLISECONDS.toMinutes(millis), TimeUnit.MILLISECONDS.toSeconds(millis) - TimeUnit.MINUTES.toSeconds(TimeUnit.MILLISECONDS.toMinutes(millis))); }

Target:
private String toTimeString(long millis) { long minutes = TimeUnit.MILLISECONDS.toMinutes(millis); long totalSeconds = TimeUnit.MILLISECONDS.toSeconds(millis); long seconds = totalSeconds - TimeUnit.MINUTES.toSeconds(minutes); return String.format("%d min, %d sec", minutes, seconds); }
Source:
public ClosableIterator<Tuple> callStoredProcedure( String storedProcedureName, ProcedureQueryParameters queryParameters, TupleContext tupleContext) { Map.Entry<String, Map> queryAndParams = buildProcedureQueryWithParams( storedProcedureName, queryParameters ); Transaction transaction = transaction( tupleContext ); if ( transaction == null ) { DatastoreProvider datastoreProvider = getServiceRegistry().getService( DatastoreProvider.class ); BoltNeo4jDatastoreProvider neo4jProvider = (BoltNeo4jDatastoreProvider) datastoreProvider; BoltNeo4jClient client = neo4jProvider.getClient(); transaction = client.getDriver().session().beginTransaction(); } StatementResult result = transaction.run( queryAndParams.getKey(), queryAndParams.getValue() ); return CollectionHelper.newClosableIterator( extractTuples( result ) ); }

Target:
public ClosableIterator<Tuple> callStoredProcedure( String storedProcedureName, ProcedureQueryParameters queryParameters, TupleContext tupleContext) { Map.Entry<String, Map<String, Object>> queryAndParams = buildProcedureQueryWithParams( storedProcedureName, queryParameters ); Transaction transaction = transaction( tupleContext ); StatementResult result = transaction.run( queryAndParams.getKey(), queryAndParams.getValue() ); try { return new BoltNeo4jMapsTupleIterator( result ); } catch (ClientException e) { switch ( e.code() ) { case BaseNeo4jDialect.PROCEDURE_CALL_FAILED_CODE: throw log.cannotExecuteStoredProcedure( storedProcedureName, e ); case BaseNeo4jDialect.PROCEDURE_NOT_FOUND_CODE: throw log.procedureWithResolvedNameDoesNotExist( storedProcedureName, e ); default: throw new HibernateException( e.getMessage() ); } } }
Source:
public boolean shouldDisplay(Map<String, Object> context) { final String buildKey = StringUtils.defaultString((String) context.get("planKey"), (String) context.get("buildKey")); final String buildNumberString = (String) context.get("buildNumber"); if (buildKey != null && buildNumberString != null) { try { int buildNumber = Integer.parseInt(buildNumberString); final ResultsSummary resultsSummary = this.resultsSummaryManager.getResultsSummary(PlanKeys.getPlanResultKey(buildKey, buildNumber)); if (resultsSummary != null) { final AllureBuildResult buildResult = AllureBuildResult.fromCustomData(resultsSummary.getCustomBuildData()); return (buildResult.hasInfo() && (resultsSummary.isFinished() || resultsSummary.isNotBuilt())); } } catch (Exception ignored) { } } return false; }

Target:
public boolean shouldDisplay(Map<String, Object> context) { final String buildKey = StringUtils.defaultString((String) context.get("planKey"), (String) context.get("buildKey")); final String buildNumberString = (String) context.get("buildNumber"); if (buildKey != null && buildNumberString != null) { try { int buildNumber = Integer.parseInt(buildNumberString); final ResultsSummary resultsSummary = this.resultsSummaryManager.getResultsSummary(PlanKeys.getPlanResultKey(buildKey, buildNumber)); if (resultsSummary != null) { final AllureBuildResult buildResult = AllureBuildResult.fromCustomData(resultsSummary.getCustomBuildData()); return (buildResult.hasInfo() && (resultsSummary.isFinished() || resultsSummary.isNotBuilt())); } } catch (Exception e) { LOGGER.error("Failed to evaluate condition", e); } } return false; }
Source:
public void execute(IAction action) { IHistoryView view = TeamUI.showHistoryFor(TeamUIPlugin.getActivePage(), getSelectedResources()[0], null); IHistoryPage page = view.getHistoryPage(); if (page instanceof GitHistoryPage){ GitHistoryPage gitHistoryPage = (GitHistoryPage) page; gitHistoryPage.setCompareMode(true); } }

Target:
public void execute(IAction action) { IHistoryView view = TeamUI.showHistoryFor(TeamUIPlugin.getActivePage(), getSelectedResources()[0], null); if (view == null) return; IHistoryPage page = view.getHistoryPage(); if (page instanceof GitHistoryPage){ GitHistoryPage gitHistoryPage = (GitHistoryPage) page; gitHistoryPage.setCompareMode(true); } }
Source:
public MySQLCustomDialect() { super(); registerColumnType(Types.BLOB, "blob"); }

Target:
public MySQLCustomDialect() { registerColumnType(Types.BLOB, "blob"); registerColumnType(Types.BOOLEAN, "varchar(1)"); }
Source:
private BrandingManager(final File etcDir) { brandingRootPath = new File(etcDir, BRANDING_PATH); }

Target:
BrandingManager(final File etcDir) { brandingRootPath = new File(etcDir, BRANDING_PATH); objectMapper = new ObjectMapper(); }