Input:
public void testInvalidFlowRunRecord() throws Exception {
    HttpResponse response = deploy(WordCountApp.class, Constants.Gateway.API_VERSION_3_TOKEN, TEST_NAMESPACE1);
    Assert.assertEquals(200, response.getStatusLine().getStatusCode());
    final Id.Program wordcountFlow1 = Id.Program.from(TEST_NAMESPACE1, "String_Node_Str", ProgramType.FLOW, "String_Node_Str");
    Assert.assertEquals("String_Node_Str", getProgramStatus(wordcountFlow1));
    startProgram(wordcountFlow1);
    waitState(wordcountFlow1, ProgramRunStatus.RUNNING.toString());
    Tasks.waitFor(1, new Callable<Integer>() {
        public Integer call() throws Exception {
            return getProgramRuns(wordcountFlow1, ProgramRunStatus.RUNNING).size();
        }
    }, 5, TimeUnit.SECONDS);
    List<RunRecord> runRecords = getProgramRuns(wordcountFlow1, ProgramRunStatus.RUNNING);
    Assert.assertEquals(1, runRecords.size());
    final RunRecord rr = runRecords.get(0);
    Assert.assertEquals(ProgramRunStatus.RUNNING, rr.getStatus());
    RuntimeInfo runtimeInfo = runtimeService.lookup(wordcountFlow1.toEntityId(), RunIds.fromString(rr.getPid()));
    ProgramController programController = runtimeInfo.getController();
    programController.stop();
    Tasks.waitFor(ProgramRunStatus.KILLED, new Callable<ProgramRunStatus>() {
        public ProgramRunStatus call() throws Exception {
            RunRecordMeta runRecord = store.getRun(wordcountFlow1.toEntityId(), rr.getPid());
            return runRecord == null ? null : runRecord.getStatus();
        }
    }, 5, TimeUnit.SECONDS, 100, TimeUnit.MILLISECONDS);
    long now = System.currentTimeMillis();
    long nowSecs = TimeUnit.MILLISECONDS.toSeconds(now);
    store.setStart(wordcountFlow1.toEntityId(), rr.getPid(), nowSecs, null, ImmutableMap.<String, String>of(), ImmutableMap.<String, String>of(), ByteBuffer.allocate(0).array());
    store.setRunning(wordcountFlow1.toEntityId(), rr.getPid(), nowSecs + 1, null, ByteBuffer.allocate(1).array());
    RunRecord runRecordMeta = store.getRun(wordcountFlow1.toEntityId(), rr.getPid());
    Assert.assertNotNull(runRecordMeta);
    Assert.assertEquals(ProgramRunStatus.RUNNING, runRecordMeta.getStatus());
    runRecords = getProgramRuns(wordcountFlow1, ProgramRunStatus.FAILED);
    Assert.assertEquals(0, runRecords.size());
    new LocalRunRecordCorrectorService(store, programStateWriter, programLifecycleService, runtimeService).startUp();
    Tasks.waitFor(1, new Callable<Integer>() {
        public Integer call() throws Exception {
            return getProgramRuns(wordcountFlow1, ProgramRunStatus.FAILED).size();
        }
    }, 30, TimeUnit.SECONDS, 1, TimeUnit.SECONDS);
}

Output:
     }, 5, TimeUnit.SECONDS, 100, TimeUnit.MILLISECONDS);
-    long now = System.currentTimeMillis();
+    long now = System.currentTimeMillis() - 1000L;
     long nowSecs = TimeUnit.MILLISECONDS.toSeconds(now);


Input:
public void traceSelected(TmfTraceSelectedSignal signal) {
    ITmfTrace trace = signal.getTrace();
    if (trace != fTrace) {
        fTrace = trace;
        Thread thread = new Thread("String_Node_Str") {
            public void run() {
                createTable();
            }
        };
        thread.start();
    }
}

Output:
         fTrace = trace;
-        Thread thread = new Thread("String_Node_Str") {
-            public void run() {
-                createTable();
-            }
-        };
-        thread.start();
+        loadTrace();
     }


Input:
public void onCheckedChanged(CompoundButton buttonView, boolean isChecked) {
    Log.d(TAG, "String_Node_Str");
    if (isChecked) {
        radioLayout.setVisibility(View.GONE);
        tabletLayout.setVisibility(View.VISIBLE);
        if (!(mCurrentRadioMode == RadioModes.AUX))
            changeRadioMode(RadioModes.AUX);
    } else {
        if (mIsPlaying)
            mPlayerService.sendPauseKey();
        radioLayout.setVisibility(View.VISIBLE);
        tabletLayout.setVisibility(View.GONE);
        if (mCurrentRadioMode == RadioModes.AUX || mCurrentRadioMode == RadioModes.CD)
            changeRadioMode(RadioModes.Radio);
    }
}

Output:
         tabletLayout.setVisibility(View.VISIBLE);
-        if (!(mCurrentRadioMode == RadioModes.AUX))
+        if (!(mCurrentRadioMode == RadioModes.AUX)) {
             changeRadioMode(RadioModes.AUX);


Input:
private void handleRPCMessage(Hashtable<String, Object> hash) {
    RPCMessage rpcMsg = new RPCMessage(hash);
    String functionName = rpcMsg.getFunctionName();
    String messageType = rpcMsg.getMessageType();
    if (messageType.equals(RPCMessage.KEY_RESPONSE)) {
        SdlTrace.logRPCEvent(InterfaceActivityDirection.Receive, new RPCResponse(rpcMsg), SDL_LIB_TRACE_KEY);
        if (isCorrelationIDProtected((new RPCResponse(hash)).getCorrelationID())) {
            if ((new RPCResponse(hash)).getCorrelationID() == REGISTER_APP_INTERFACE_CORRELATION_ID && _advancedLifecycleManagementEnabled && functionName.equals(FunctionID.REGISTER_APP_INTERFACE.toString())) {
                final RegisterAppInterfaceResponse msg = new RegisterAppInterfaceResponse(hash);
                if (msg.getSuccess()) {
                    _appInterfaceRegisterd = true;
                }
                processRaiResponse(msg);
                _systemCapabilityManager.parseRAIResponse(msg);
                Intent sendIntent = createBroadcastIntent();
                updateBroadcastIntent(sendIntent, "String_Node_Str", FunctionID.REGISTER_APP_INTERFACE.toString());
                updateBroadcastIntent(sendIntent, "String_Node_Str", RPCMessage.KEY_RESPONSE);
                updateBroadcastIntent(sendIntent, "String_Node_Str", msg.getSuccess());
                updateBroadcastIntent(sendIntent, "String_Node_Str", msg.getInfo());
                updateBroadcastIntent(sendIntent, "String_Node_Str", msg.getResultCode().toString());
                updateBroadcastIntent(sendIntent, "String_Node_Str", serializeJSON(msg));
                updateBroadcastIntent(sendIntent, "String_Node_Str", msg.getCorrelationID());
                sendBroadcastIntent(sendIntent);
                _autoActivateIdReturned = "String_Node_Str";
                _prerecordedSpeech = msg.getPrerecordedSpeech();
                _sdlLanguage = msg.getLanguage();
                _hmiDisplayLanguage = msg.getHmiDisplayLanguage();
                _sdlMsgVersion = msg.getSdlMsgVersion();
                _vehicleType = msg.getVehicleType();
                _systemSoftwareVersion = msg.getSystemSoftwareVersion();
                _proxyVersionInfo = msg.getProxyVersionInfo();
                if (_bAppResumeEnabled) {
                    if ((_sdlMsgVersion.getMajorVersion() > 2) && (_lastHashID != null) && (msg.getSuccess()) && (msg.getResultCode() != Result.RESUME_FAILED))
                        _bResumeSuccess = true;
                    else {
                        _bResumeSuccess = false;
                        _lastHashID = null;
                    }
                }
                _diagModes = msg.getSupportedDiagModes();
                String sVersionInfo = "String_Node_Str" + _proxyVersionInfo;
                if (!isDebugEnabled()) {
                    enableDebugTool();
                    DebugTool.logInfo(sVersionInfo, false);
                    disableDebugTool();
                } else
                    DebugTool.logInfo(sVersionInfo, false);
                sendIntent = createBroadcastIntent();
                updateBroadcastIntent(sendIntent, "String_Node_Str", "String_Node_Str");
                updateBroadcastIntent(sendIntent, "String_Node_Str", sVersionInfo);
                sendBroadcastIntent(sendIntent);
                _sdlConnectionState = SdlConnectionState.SDL_CONNECTED;
                if (!msg.getSuccess()) {
                    notifyProxyClosed("String_Node_Str", new SdlException("String_Node_Str" + msg.getResultCode(), SdlExceptionCause.SDL_REGISTRATION_ERROR), SdlDisconnectedReason.SDL_REGISTRATION_ERROR);
                }
                if (_callbackToUIThread) {
                    _mainUIHandler.post(new Runnable() {
                        public void run() {
                            if (_proxyListener instanceof IProxyListener) {
                                ((IProxyListener) _proxyListener).onRegisterAppInterfaceResponse(msg);
                            }
                            onRPCResponseReceived(msg);
                        }
                    });
                } else {
                    if (_proxyListener instanceof IProxyListener) {
                        ((IProxyListener) _proxyListener).onRegisterAppInterfaceResponse(msg);
                    }
                    onRPCResponseReceived(msg);
                }
            } else if ((new RPCResponse(hash)).getCorrelationID() == POLICIES_CORRELATION_ID && functionName.equals(FunctionID.ON_ENCODED_SYNC_P_DATA.toString())) {
                Log.i("String_Node_Str", "String_Node_Str");
                final OnSystemRequest msg = new OnSystemRequest(hash);
                if ((msg.getUrl() != null)) {
                    Thread handleOffboardTransmissionThread = new Thread() {
                        public void run() {
                            sendOnSystemRequestToUrl(msg);
                        }
                    };
                    handleOffboardTransmissionThread.start();
                }
            } else if ((new RPCResponse(hash)).getCorrelationID() == POLICIES_CORRELATION_ID && functionName.equals(FunctionID.ENCODED_SYNC_P_DATA.toString())) {
                Log.i("String_Node_Str", "String_Node_Str");
                final SystemRequestResponse msg = new SystemRequestResponse(hash);
                Intent sendIntent = createBroadcastIntent();
                updateBroadcastIntent(sendIntent, "String_Node_Str", FunctionID.SYSTEM_REQUEST.toString());
                updateBroadcastIntent(sendIntent, "String_Node_Str", RPCMessage.KEY_RESPONSE);
                updateBroadcastIntent(sendIntent, "String_Node_Str", msg.getSuccess());
                updateBroadcastIntent(sendIntent, "String_Node_Str", msg.getInfo());
                updateBroadcastIntent(sendIntent, "String_Node_Str", msg.getResultCode().toString());
                updateBroadcastIntent(sendIntent, "String_Node_Str", msg.getCorrelationID());
                sendBroadcastIntent(sendIntent);
            } else if ((new RPCResponse(hash)).getCorrelationID() == POLICIES_CORRELATION_ID && functionName.equals(FunctionID.SYSTEM_REQUEST.toString())) {
                final SystemRequestResponse msg = new SystemRequestResponse(hash);
                Intent sendIntent = createBroadcastIntent();
                updateBroadcastIntent(sendIntent, "String_Node_Str", FunctionID.SYSTEM_REQUEST.toString());
                updateBroadcastIntent(sendIntent, "String_Node_Str", RPCMessage.KEY_RESPONSE);
                updateBroadcastIntent(sendIntent, "String_Node_Str", msg.getSuccess());
                updateBroadcastIntent(sendIntent, "String_Node_Str", msg.getInfo());
                updateBroadcastIntent(sendIntent, "String_Node_Str", msg.getResultCode().toString());
                updateBroadcastIntent(sendIntent, "String_Node_Str", msg.getCorrelationID());
                updateBroadcastIntent(sendIntent, "String_Node_Str", serializeJSON(msg));
                sendBroadcastIntent(sendIntent);
            } else if (functionName.equals(FunctionID.UNREGISTER_APP_INTERFACE.toString())) {
                _appInterfaceRegisterd = false;
                synchronized (APP_INTERFACE_REGISTERED_LOCK) {
                    APP_INTERFACE_REGISTERED_LOCK.notify();
                }
                final UnregisterAppInterfaceResponse msg = new UnregisterAppInterfaceResponse(hash);
                Intent sendIntent = createBroadcastIntent();
                updateBroadcastIntent(sendIntent, "String_Node_Str", FunctionID.UNREGISTER_APP_INTERFACE.toString());
                updateBroadcastIntent(sendIntent, "String_Node_Str", RPCMessage.KEY_RESPONSE);
                updateBroadcastIntent(sendIntent, "String_Node_Str", msg.getSuccess());
                updateBroadcastIntent(sendIntent, "String_Node_Str", msg.getInfo());
                updateBroadcastIntent(sendIntent, "String_Node_Str", msg.getResultCode().toString());
                updateBroadcastIntent(sendIntent, "String_Node_Str", serializeJSON(msg));
                updateBroadcastIntent(sendIntent, "String_Node_Str", msg.getCorrelationID());
                sendBroadcastIntent(sendIntent);
            }
            return;
        }
        if (functionName.equals(FunctionID.REGISTER_APP_INTERFACE.toString())) {
            final RegisterAppInterfaceResponse msg = new RegisterAppInterfaceResponse(hash);
            if (msg.getSuccess()) {
                _appInterfaceRegisterd = true;
            }
            processRaiResponse(msg);
            _systemCapabilityManager.parseRAIResponse(msg);
            _autoActivateIdReturned = "String_Node_Str";
            _prerecordedSpeech = msg.getPrerecordedSpeech();
            _sdlLanguage = msg.getLanguage();
            _hmiDisplayLanguage = msg.getHmiDisplayLanguage();
            _sdlMsgVersion = msg.getSdlMsgVersion();
            _vehicleType = msg.getVehicleType();
            _systemSoftwareVersion = msg.getSystemSoftwareVersion();
            _proxyVersionInfo = msg.getProxyVersionInfo();
            if (_bAppResumeEnabled) {
                if ((_sdlMsgVersion.getMajorVersion() > 2) && (_lastHashID != null) && (msg.getSuccess()) && (msg.getResultCode() != Result.RESUME_FAILED))
                    _bResumeSuccess = true;
                else {
                    _bResumeSuccess = false;
                    _lastHashID = null;
                }
            }
            _diagModes = msg.getSupportedDiagModes();
            if (!isDebugEnabled()) {
                enableDebugTool();
                DebugTool.logInfo("String_Node_Str" + _proxyVersionInfo);
                disableDebugTool();
            } else
                DebugTool.logInfo("String_Node_Str" + _proxyVersionInfo);
            if (_advancedLifecycleManagementEnabled) {
                _sdlConnectionState = SdlConnectionState.SDL_CONNECTED;
                if (!msg.getSuccess()) {
                    notifyProxyClosed("String_Node_Str", new SdlException("String_Node_Str" + msg.getResultCode(), SdlExceptionCause.SDL_REGISTRATION_ERROR), SdlDisconnectedReason.SDL_REGISTRATION_ERROR);
                }
            } else {
                if (_callbackToUIThread) {
                    _mainUIHandler.post(new Runnable() {
                        public void run() {
                            if (_proxyListener instanceof IProxyListener) {
                                ((IProxyListener) _proxyListener).onRegisterAppInterfaceResponse(msg);
                            }
                            onRPCResponseReceived(msg);
                        }
                    });
                } else {
                    if (_proxyListener instanceof IProxyListener) {
                        ((IProxyListener) _proxyListener).onRegisterAppInterfaceResponse(msg);
                    }
                    onRPCResponseReceived(msg);
                }
            }
        } else if (functionName.equals(FunctionID.SPEAK.toString())) {
            final SpeakResponse msg = new SpeakResponse(hash);
            if (_callbackToUIThread) {
                _mainUIHandler.post(new Runnable() {
                    public void run() {
                        _proxyListener.onSpeakResponse(msg);
                        onRPCResponseReceived(msg);
                    }
                });
            } else {
                _proxyListener.onSpeakResponse(msg);
                onRPCResponseReceived(msg);
            }
        } else if (functionName.equals(FunctionID.ALERT.toString())) {
            final AlertResponse msg = new AlertResponse(hash);
            if (_callbackToUIThread) {
                _mainUIHandler.post(new Runnable() {
                    public void run() {
                        _proxyListener.onAlertResponse(msg);
                        onRPCResponseReceived(msg);
                    }
                });
            } else {
                _proxyListener.onAlertResponse(msg);
                onRPCResponseReceived(msg);
            }
        } else if (functionName.equals(FunctionID.SHOW.toString())) {
            final ShowResponse msg = new ShowResponse(hash);
            if (_callbackToUIThread) {
                _mainUIHandler.post(new Runnable() {
                    public void run() {
                        _proxyListener.onShowResponse(msg);
                        onRPCResponseReceived(msg);
                    }
                });
            } else {
                _proxyListener.onShowResponse(msg);
                onRPCResponseReceived(msg);
            }
        } else if (functionName.equals(FunctionID.ADD_COMMAND.toString())) {
            final AddCommandResponse msg = new AddCommandResponse(hash);
            if (_callbackToUIThread) {
                _mainUIHandler.post(new Runnable() {
                    public void run() {
                        _proxyListener.onAddCommandResponse(msg);
                        onRPCResponseReceived(msg);
                    }
                });
            } else {
                _proxyListener.onAddCommandResponse(msg);
                onRPCResponseReceived(msg);
            }
        } else if (functionName.equals(FunctionID.DELETE_COMMAND.toString())) {
            final DeleteCommandResponse msg = new DeleteCommandResponse(hash);
            if (_callbackToUIThread) {
                _mainUIHandler.post(new Runnable() {
                    public void run() {
                        _proxyListener.onDeleteCommandResponse(msg);
                        onRPCResponseReceived(msg);
                    }
                });
            } else {
                _proxyListener.onDeleteCommandResponse(msg);
                onRPCResponseReceived(msg);
            }
        } else if (functionName.equals(FunctionID.ADD_SUB_MENU.toString())) {
            final AddSubMenuResponse msg = new AddSubMenuResponse(hash);
            if (_callbackToUIThread) {
                _mainUIHandler.post(new Runnable() {
                    public void run() {
                        _proxyListener.onAddSubMenuResponse(msg);
                        onRPCResponseReceived(msg);
                    }
                });
            } else {
                _proxyListener.onAddSubMenuResponse(msg);
                onRPCResponseReceived(msg);
            }
        } else if (functionName.equals(FunctionID.DELETE_SUB_MENU.toString())) {
            final DeleteSubMenuResponse msg = new DeleteSubMenuResponse(hash);
            if (_callbackToUIThread) {
                _mainUIHandler.post(new Runnable() {
                    public void run() {
                        _proxyListener.onDeleteSubMenuResponse(msg);
                        onRPCResponseReceived(msg);
                    }
                });
            } else {
                _proxyListener.onDeleteSubMenuResponse(msg);
                onRPCResponseReceived(msg);
            }
        } else if (functionName.equals(FunctionID.SUBSCRIBE_BUTTON.toString())) {
            final SubscribeButtonResponse msg = new SubscribeButtonResponse(hash);
            if (_callbackToUIThread) {
                _mainUIHandler.post(new Runnable() {
                    public void run() {
                        _proxyListener.onSubscribeButtonResponse(msg);
                        onRPCResponseReceived(msg);
                    }
                });
            } else {
                _proxyListener.onSubscribeButtonResponse(msg);
                onRPCResponseReceived(msg);
            }
        } else if (functionName.equals(FunctionID.UNSUBSCRIBE_BUTTON.toString())) {
            final UnsubscribeButtonResponse msg = new UnsubscribeButtonResponse(hash);
            if (_callbackToUIThread) {
                _mainUIHandler.post(new Runnable() {
                    public void run() {
                        _proxyListener.onUnsubscribeButtonResponse(msg);
                        onRPCResponseReceived(msg);
                    }
                });
            } else {
                _proxyListener.onUnsubscribeButtonResponse(msg);
                onRPCResponseReceived(msg);
            }
        } else if (functionName.equals(FunctionID.SET_MEDIA_CLOCK_TIMER.toString())) {
            final SetMediaClockTimerResponse msg = new SetMediaClockTimerResponse(hash);
            if (_callbackToUIThread) {
                _mainUIHandler.post(new Runnable() {
                    public void run() {
                        _proxyListener.onSetMediaClockTimerResponse(msg);
                        onRPCResponseReceived(msg);
                    }
                });
            } else {
                _proxyListener.onSetMediaClockTimerResponse(msg);
                onRPCResponseReceived(msg);
            }
        } else if (functionName.equals(FunctionID.ENCODED_SYNC_P_DATA.toString())) {
            final SystemRequestResponse msg = new SystemRequestResponse(hash);
            Intent sendIntent = createBroadcastIntent();
            updateBroadcastIntent(sendIntent, "String_Node_Str", FunctionID.SYSTEM_REQUEST.toString());
            updateBroadcastIntent(sendIntent, "String_Node_Str", RPCMessage.KEY_RESPONSE);
            updateBroadcastIntent(sendIntent, "String_Node_Str", msg.getSuccess());
            updateBroadcastIntent(sendIntent, "String_Node_Str", msg.getInfo());
            updateBroadcastIntent(sendIntent, "String_Node_Str", msg.getResultCode().toString());
            updateBroadcastIntent(sendIntent, "String_Node_Str", msg.getCorrelationID());
            sendBroadcastIntent(sendIntent);
            if (_callbackToUIThread) {
                _mainUIHandler.post(new Runnable() {
                    public void run() {
                        _proxyListener.onSystemRequestResponse(msg);
                        onRPCResponseReceived(msg);
                    }
                });
            } else {
                _proxyListener.onSystemRequestResponse(msg);
                onRPCResponseReceived(msg);
            }
        } else if (functionName.equals(FunctionID.CREATE_INTERACTION_CHOICE_SET.toString())) {
            final CreateInteractionChoiceSetResponse msg = new CreateInteractionChoiceSetResponse(hash);
            if (_callbackToUIThread) {
                _mainUIHandler.post(new Runnable() {
                    public void run() {
                        _proxyListener.onCreateInteractionChoiceSetResponse(msg);
                        onRPCResponseReceived(msg);
                    }
                });
            } else {
                _proxyListener.onCreateInteractionChoiceSetResponse(msg);
                onRPCResponseReceived(msg);
            }
        } else if (functionName.equals(FunctionID.DELETE_INTERACTION_CHOICE_SET.toString())) {
            final DeleteInteractionChoiceSetResponse msg = new DeleteInteractionChoiceSetResponse(hash);
            if (_callbackToUIThread) {
                _mainUIHandler.post(new Runnable() {
                    public void run() {
                        _proxyListener.onDeleteInteractionChoiceSetResponse(msg);
                        onRPCResponseReceived(msg);
                    }
                });
            } else {
                _proxyListener.onDeleteInteractionChoiceSetResponse(msg);
                onRPCResponseReceived(msg);
            }
        } else if (functionName.equals(FunctionID.PERFORM_INTERACTION.toString())) {
            final PerformInteractionResponse msg = new PerformInteractionResponse(hash);
            if (_callbackToUIThread) {
                _mainUIHandler.post(new Runnable() {
                    public void run() {
                        _proxyListener.onPerformInteractionResponse(msg);
                        onRPCResponseReceived(msg);
                    }
                });
            } else {
                _proxyListener.onPerformInteractionResponse(msg);
                onRPCResponseReceived(msg);
            }
        } else if (functionName.equals(FunctionID.SET_GLOBAL_PROPERTIES.toString())) {
            final SetGlobalPropertiesResponse msg = new SetGlobalPropertiesResponse(hash);
            if (_callbackToUIThread) {
                _mainUIHandler.post(new Runnable() {
                    public void run() {
                        _proxyListener.onSetGlobalPropertiesResponse(msg);
                        onRPCResponseReceived(msg);
                    }
                });
            } else {
                _proxyListener.onSetGlobalPropertiesResponse(msg);
                onRPCResponseReceived(msg);
            }
        } else if (functionName.equals(FunctionID.RESET_GLOBAL_PROPERTIES.toString())) {
            final ResetGlobalPropertiesResponse msg = new ResetGlobalPropertiesResponse(hash);
            if (_callbackToUIThread) {
                _mainUIHandler.post(new Runnable() {
                    public void run() {
                        _proxyListener.onResetGlobalPropertiesResponse(msg);
                        onRPCResponseReceived(msg);
                    }
                });
            } else {
                _proxyListener.onResetGlobalPropertiesResponse(msg);
                onRPCResponseReceived(msg);
            }
        } else if (functionName.equals(FunctionID.UNREGISTER_APP_INTERFACE.toString())) {
            _appInterfaceRegisterd = false;
            synchronized (APP_INTERFACE_REGISTERED_LOCK) {
                APP_INTERFACE_REGISTERED_LOCK.notify();
            }
            final UnregisterAppInterfaceResponse msg = new UnregisterAppInterfaceResponse(hash);
            Intent sendIntent = createBroadcastIntent();
            updateBroadcastIntent(sendIntent, "String_Node_Str", FunctionID.UNREGISTER_APP_INTERFACE.toString());
            updateBroadcastIntent(sendIntent, "String_Node_Str", RPCMessage.KEY_RESPONSE);
            updateBroadcastIntent(sendIntent, "String_Node_Str", msg.getSuccess());
            updateBroadcastIntent(sendIntent, "String_Node_Str", msg.getInfo());
            updateBroadcastIntent(sendIntent, "String_Node_Str", msg.getResultCode().toString());
            updateBroadcastIntent(sendIntent, "String_Node_Str", serializeJSON(msg));
            updateBroadcastIntent(sendIntent, "String_Node_Str", msg.getCorrelationID());
            sendBroadcastIntent(sendIntent);
            if (_callbackToUIThread) {
                _mainUIHandler.post(new Runnable() {
                    public void run() {
                        if (_proxyListener instanceof IProxyListener) {
                            ((IProxyListener) _proxyListener).onUnregisterAppInterfaceResponse(msg);
                        }
                        onRPCResponseReceived(msg);
                    }
                });
            } else {
                if (_proxyListener instanceof IProxyListener) {
                    ((IProxyListener) _proxyListener).onUnregisterAppInterfaceResponse(msg);
                }
                onRPCResponseReceived(msg);
            }
            notifyProxyClosed("String_Node_Str", null, SdlDisconnectedReason.APP_INTERFACE_UNREG);
        } else if (functionName.equals(FunctionID.GENERIC_RESPONSE.toString())) {
            final GenericResponse msg = new GenericResponse(hash);
            if (_callbackToUIThread) {
                _mainUIHandler.post(new Runnable() {
                    public void run() {
                        _proxyListener.onGenericResponse(msg);
                        onRPCResponseReceived(msg);
                    }
                });
            } else {
                _proxyListener.onGenericResponse(msg);
                onRPCResponseReceived(msg);
            }
        } else if (functionName.equals(FunctionID.SLIDER.toString())) {
            final SliderResponse msg = new SliderResponse(hash);
            if (_callbackToUIThread) {
                _mainUIHandler.post(new Runnable() {
                    public void run() {
                        _proxyListener.onSliderResponse(msg);
                        onRPCResponseReceived(msg);
                    }
                });
            } else {
                _proxyListener.onSliderResponse(msg);
                onRPCResponseReceived(msg);
            }
        } else if (functionName.equals(FunctionID.PUT_FILE.toString())) {
            final PutFileResponse msg = new PutFileResponse(hash);
            if (_callbackToUIThread) {
                _mainUIHandler.post(new Runnable() {
                    public void run() {
                        _proxyListener.onPutFileResponse(msg);
                        onRPCResponseReceived(msg);
                        notifyPutFileStreamResponse(msg);
                    }
                });
            } else {
                _proxyListener.onPutFileResponse(msg);
                onRPCResponseReceived(msg);
                notifyPutFileStreamResponse(msg);
            }
        } else if (functionName.equals(FunctionID.DELETE_FILE.toString())) {
            final DeleteFileResponse msg = new DeleteFileResponse(hash);
            if (_callbackToUIThread) {
                _mainUIHandler.post(new Runnable() {
                    public void run() {
                        _proxyListener.onDeleteFileResponse(msg);
                        onRPCResponseReceived(msg);
                    }
                });
            } else {
                _proxyListener.onDeleteFileResponse(msg);
                onRPCResponseReceived(msg);
            }
        } else if (functionName.equals(FunctionID.LIST_FILES.toString())) {
            final ListFilesResponse msg = new ListFilesResponse(hash);
            if (_callbackToUIThread) {
                _mainUIHandler.post(new Runnable() {
                    public void run() {
                        _proxyListener.onListFilesResponse(msg);
                        onRPCResponseReceived(msg);
                    }
                });
            } else {
                _proxyListener.onListFilesResponse(msg);
                onRPCResponseReceived(msg);
            }
        } else if (functionName.equals(FunctionID.SET_APP_ICON.toString())) {
            final SetAppIconResponse msg = new SetAppIconResponse(hash);
            if (_callbackToUIThread) {
                _mainUIHandler.post(new Runnable() {
                    public void run() {
                        _proxyListener.onSetAppIconResponse(msg);
                        onRPCResponseReceived(msg);
                    }
                });
            } else {
                _proxyListener.onSetAppIconResponse(msg);
                onRPCResponseReceived(msg);
            }
        } else if (functionName.equals(FunctionID.SCROLLABLE_MESSAGE.toString())) {
            final ScrollableMessageResponse msg = new ScrollableMessageResponse(hash);
            if (_callbackToUIThread) {
                _mainUIHandler.post(new Runnable() {
                    public void run() {
                        _proxyListener.onScrollableMessageResponse(msg);
                        onRPCResponseReceived(msg);
                    }
                });
            } else {
                _proxyListener.onScrollableMessageResponse(msg);
                onRPCResponseReceived(msg);
            }
        } else if (functionName.equals(FunctionID.CHANGE_REGISTRATION.toString())) {
            final ChangeRegistrationResponse msg = new ChangeRegistrationResponse(hash);
            if (_callbackToUIThread) {
                _mainUIHandler.post(new Runnable() {
                    public void run() {
                        _proxyListener.onChangeRegistrationResponse(msg);
                        onRPCResponseReceived(msg);
                    }
                });
            } else {
                _proxyListener.onChangeRegistrationResponse(msg);
                onRPCResponseReceived(msg);
            }
        } else if (functionName.equals(FunctionID.SET_DISPLAY_LAYOUT.toString())) {
            final SetDisplayLayoutResponse msg = new SetDisplayLayoutResponse(hash);
            if (msg.getSuccess() && _systemCapabilityManager != null) {
                _systemCapabilityManager.setCapability(SystemCapabilityType.DISPLAY, msg.getDisplayCapabilities());
                _systemCapabilityManager.setCapability(SystemCapabilityType.BUTTON, msg.getButtonCapabilities());
                _systemCapabilityManager.setCapability(SystemCapabilityType.PRESET_BANK, msg.getPresetBankCapabilities());
                _systemCapabilityManager.setCapability(SystemCapabilityType.SOFTBUTTON, msg.getSoftButtonCapabilities());
            }
            if (_callbackToUIThread) {
                _mainUIHandler.post(new Runnable() {
                    public void run() {
                        _proxyListener.onSetDisplayLayoutResponse(msg);
                        onRPCResponseReceived(msg);
                    }
                });
            } else {
                _proxyListener.onSetDisplayLayoutResponse(msg);
                onRPCResponseReceived(msg);
            }
        } else if (functionName.equals(FunctionID.PERFORM_AUDIO_PASS_THRU.toString())) {
            final PerformAudioPassThruResponse msg = new PerformAudioPassThruResponse(hash);
            if (_callbackToUIThread) {
                _mainUIHandler.post(new Runnable() {
                    public void run() {
                        _proxyListener.onPerformAudioPassThruResponse(msg);
                        onRPCResponseReceived(msg);
                    }
                });
            } else {
                _proxyListener.onPerformAudioPassThruResponse(msg);
                onRPCResponseReceived(msg);
            }
        } else if (functionName.equals(FunctionID.END_AUDIO_PASS_THRU.toString())) {
            final EndAudioPassThruResponse msg = new EndAudioPassThruResponse(hash);
            if (_callbackToUIThread) {
                _mainUIHandler.post(new Runnable() {
                    public void run() {
                        _proxyListener.onEndAudioPassThruResponse(msg);
                        onRPCResponseReceived(msg);
                    }
                });
            } else {
                _proxyListener.onEndAudioPassThruResponse(msg);
                onRPCResponseReceived(msg);
            }
        } else if (functionName.equals(FunctionID.SUBSCRIBE_VEHICLE_DATA.toString())) {
            final SubscribeVehicleDataResponse msg = new SubscribeVehicleDataResponse(hash);
            if (_callbackToUIThread) {
                _mainUIHandler.post(new Runnable() {
                    public void run() {
                        _proxyListener.onSubscribeVehicleDataResponse(msg);
                        onRPCResponseReceived(msg);
                    }
                });
            } else {
                _proxyListener.onSubscribeVehicleDataResponse(msg);
                onRPCResponseReceived(msg);
            }
        } else if (functionName.equals(FunctionID.UNSUBSCRIBE_VEHICLE_DATA.toString())) {
            final UnsubscribeVehicleDataResponse msg = new UnsubscribeVehicleDataResponse(hash);
            if (_callbackToUIThread) {
                _mainUIHandler.post(new Runnable() {
                    public void run() {
                        _proxyListener.onUnsubscribeVehicleDataResponse(msg);
                        onRPCResponseReceived(msg);
                    }
                });
            } else {
                _proxyListener.onUnsubscribeVehicleDataResponse(msg);
                onRPCResponseReceived(msg);
            }
        } else if (functionName.equals(FunctionID.GET_VEHICLE_DATA.toString())) {
            final GetVehicleDataResponse msg = new GetVehicleDataResponse(hash);
            if (_callbackToUIThread) {
                _mainUIHandler.post(new Runnable() {
                    public void run() {
                        _proxyListener.onGetVehicleDataResponse(msg);
                        onRPCResponseReceived(msg);
                    }
                });
            } else {
                _proxyListener.onGetVehicleDataResponse(msg);
                onRPCResponseReceived(msg);
            }
        } else if (functionName.equals(FunctionID.SUBSCRIBE_WAY_POINTS.toString())) {
            final SubscribeWayPointsResponse msg = new SubscribeWayPointsResponse(hash);
            if (_callbackToUIThread) {
                _mainUIHandler.post(new Runnable() {
                    public void run() {
                        _proxyListener.onSubscribeWayPointsResponse(msg);
                        onRPCResponseReceived(msg);
                    }
                });
            } else {
                _proxyListener.onSubscribeWayPointsResponse(msg);
                onRPCResponseReceived(msg);
            }
        } else if (functionName.equals(FunctionID.UNSUBSCRIBE_WAY_POINTS.toString())) {
            final UnsubscribeWayPointsResponse msg = new UnsubscribeWayPointsResponse(hash);
            if (_callbackToUIThread) {
                _mainUIHandler.post(new Runnable() {
                    public void run() {
                        _proxyListener.onUnsubscribeWayPointsResponse(msg);
                        onRPCResponseReceived(msg);
                    }
                });
            } else {
                _proxyListener.onUnsubscribeWayPointsResponse(msg);
                onRPCResponseReceived(msg);
            }
        } else if (functionName.equals(FunctionID.GET_WAY_POINTS.toString())) {
            final GetWayPointsResponse msg = new GetWayPointsResponse(hash);
            if (_callbackToUIThread) {
                _mainUIHandler.post(new Runnable() {
                    public void run() {
                        _proxyListener.onGetWayPointsResponse(msg);
                        onRPCResponseReceived(msg);
                    }
                });
            } else {
                _proxyListener.onGetWayPointsResponse(msg);
                onRPCResponseReceived(msg);
            }
        } else if (functionName.equals(FunctionID.READ_DID.toString())) {
            final ReadDIDResponse msg = new ReadDIDResponse(hash);
            if (_callbackToUIThread) {
                _mainUIHandler.post(new Runnable() {
                    public void run() {
                        _proxyListener.onReadDIDResponse(msg);
                        onRPCResponseReceived(msg);
                    }
                });
            } else {
                _proxyListener.onReadDIDResponse(msg);
                onRPCResponseReceived(msg);
            }
        } else if (functionName.equals(FunctionID.GET_DTCS.toString())) {
            final GetDTCsResponse msg = new GetDTCsResponse(hash);
            if (_callbackToUIThread) {
                _mainUIHandler.post(new Runnable() {
                    public void run() {
                        _proxyListener.onGetDTCsResponse(msg);
                        onRPCResponseReceived(msg);
                    }
                });
            } else {
                _proxyListener.onGetDTCsResponse(msg);
                onRPCResponseReceived(msg);
            }
        } else if (functionName.equals(FunctionID.DIAGNOSTIC_MESSAGE.toString())) {
            final DiagnosticMessageResponse msg = new DiagnosticMessageResponse(hash);
            if (_callbackToUIThread) {
                _mainUIHandler.post(new Runnable() {
                    public void run() {
                        _proxyListener.onDiagnosticMessageResponse(msg);
                        onRPCResponseReceived(msg);
                    }
                });
            } else {
                _proxyListener.onDiagnosticMessageResponse(msg);
                onRPCResponseReceived(msg);
            }
        } else if (functionName.equals(FunctionID.SYSTEM_REQUEST.toString())) {
            final SystemRequestResponse msg = new SystemRequestResponse(hash);
            if (_callbackToUIThread) {
                _mainUIHandler.post(new Runnable() {
                    public void run() {
                        _proxyListener.onSystemRequestResponse(msg);
                        onRPCResponseReceived(msg);
                    }
                });
            } else {
                _proxyListener.onSystemRequestResponse(msg);
                onRPCResponseReceived(msg);
            }
        } else if (functionName.equals(FunctionID.SEND_LOCATION.toString())) {
            final SendLocationResponse msg = new SendLocationResponse(hash);
            if (_callbackToUIThread) {
                _mainUIHandler.post(new Runnable() {
                    public void run() {
                        _proxyListener.onSendLocationResponse(msg);
                        onRPCResponseReceived(msg);
                    }
                });
            } else {
                _proxyListener.onSendLocationResponse(msg);
                onRPCResponseReceived(msg);
            }
        } else if (functionName.equals(FunctionID.DIAL_NUMBER.toString())) {
            final DialNumberResponse msg = new DialNumberResponse(hash);
            if (_callbackToUIThread) {
                _mainUIHandler.post(new Runnable() {
                    public void run() {
                        _proxyListener.onDialNumberResponse(msg);
                        onRPCResponseReceived(msg);
                    }
                });
            } else {
                _proxyListener.onDialNumberResponse(msg);
                onRPCResponseReceived(msg);
            }
        } else if (functionName.equals(FunctionID.SHOW_CONSTANT_TBT.toString())) {
            final ShowConstantTbtResponse msg = new ShowConstantTbtResponse(hash);
            if (_callbackToUIThread) {
                _mainUIHandler.post(new Runnable() {
                    public void run() {
                        _proxyListener.onShowConstantTbtResponse(msg);
                        onRPCResponseReceived(msg);
                    }
                });
            } else {
                _proxyListener.onShowConstantTbtResponse(msg);
                onRPCResponseReceived(msg);
            }
        } else if (functionName.equals(FunctionID.ALERT_MANEUVER.toString())) {
            final AlertManeuverResponse msg = new AlertManeuverResponse(hash);
            if (_callbackToUIThread) {
                _mainUIHandler.post(new Runnable() {
                    public void run() {
                        _proxyListener.onAlertManeuverResponse(msg);
                        onRPCResponseReceived(msg);
                    }
                });
            } else {
                _proxyListener.onAlertManeuverResponse(msg);
                onRPCResponseReceived(msg);
            }
        } else if (functionName.equals(FunctionID.UPDATE_TURN_LIST.toString())) {
            final UpdateTurnListResponse msg = new UpdateTurnListResponse(hash);
            if (_callbackToUIThread) {
                _mainUIHandler.post(new Runnable() {
                    public void run() {
                        _proxyListener.onUpdateTurnListResponse(msg);
                        onRPCResponseReceived(msg);
                    }
                });
            } else {
                _proxyListener.onUpdateTurnListResponse(msg);
                onRPCResponseReceived(msg);
            }
        } else if (functionName.equals(FunctionID.SET_INTERIOR_VEHICLE_DATA.toString())) {
            final SetInteriorVehicleDataResponse msg = new SetInteriorVehicleDataResponse(hash);
            if (_callbackToUIThread) {
                _mainUIHandler.post(new Runnable() {
                    public void run() {
                        _proxyListener.onSetInteriorVehicleDataResponse(msg);
                        onRPCResponseReceived(msg);
                    }
                });
            } else {
                _proxyListener.onSetInteriorVehicleDataResponse(msg);
                onRPCResponseReceived(msg);
            }
        } else if (functionName.equals(FunctionID.GET_INTERIOR_VEHICLE_DATA.toString())) {
            final GetInteriorVehicleDataResponse msg = new GetInteriorVehicleDataResponse(hash);
            if (_callbackToUIThread) {
                _mainUIHandler.post(new Runnable() {
                    public void run() {
                        _proxyListener.onGetInteriorVehicleDataResponse(msg);
                        onRPCResponseReceived(msg);
                    }
                });
            } else {
                _proxyListener.onGetInteriorVehicleDataResponse(msg);
                onRPCResponseReceived(msg);
            }
        } else if (functionName.equals(FunctionID.GET_SYSTEM_CAPABILITY.toString())) {
            final GetSystemCapabilityResponse msg = new GetSystemCapabilityResponse(hash);
            if (_callbackToUIThread) {
                _mainUIHandler.post(new Runnable() {
                    public void run() {
                        _proxyListener.onGetSystemCapabilityResponse(msg);
                        onRPCResponseReceived(msg);
                    }
                });
            } else {
                _proxyListener.onGetSystemCapabilityResponse(msg);
                onRPCResponseReceived(msg);
            }
        } else if (functionName.equals(FunctionID.BUTTON_PRESS.toString())) {
            final ButtonPressResponse msg = new ButtonPressResponse(hash);
            if (_callbackToUIThread) {
                _mainUIHandler.post(new Runnable() {
                    public void run() {
                        _proxyListener.onButtonPressResponse(msg);
                        onRPCResponseReceived(msg);
                    }
                });
            } else {
                _proxyListener.onButtonPressResponse(msg);
                onRPCResponseReceived(msg);
            }
        } else if (functionName.equals(FunctionID.SEND_HAPTIC_DATA.toString())) {
            final SendHapticDataResponse msg = new SendHapticDataResponse(hash);
            if (_callbackToUIThread) {
                _mainUIHandler.post(new Runnable() {
                    public void run() {
                        _proxyListener.onSendHapticDataResponse(msg);
                        onRPCResponseReceived(msg);
                    }
                });
            } else {
                _proxyListener.onSendHapticDataResponse(msg);
                onRPCResponseReceived(msg);
            }
        } else {
            if (_sdlMsgVersion != null) {
                DebugTool.logError("String_Node_Str" + functionName + "String_Node_Str" + _sdlMsgVersion);
            } else {
                DebugTool.logError("String_Node_Str" + functionName);
            }
        }
    } else if (messageType.equals(RPCMessage.KEY_NOTIFICATION)) {
        SdlTrace.logRPCEvent(InterfaceActivityDirection.Receive, new RPCNotification(rpcMsg), SDL_LIB_TRACE_KEY);
        if (functionName.equals(FunctionID.ON_HMI_STATUS.toString())) {
            final OnHMIStatus msg = new OnHMIStatus(hash);
            if (sdlSession != null) {
                sdlSession.getLockScreenMan().setHMILevel(msg.getHmiLevel());
            }
            msg.setFirstRun(firstTimeFull);
            if (msg.getHmiLevel() == HMILevel.HMI_FULL)
                firstTimeFull = false;
            if (msg.getHmiLevel() != _hmiLevel || msg.getAudioStreamingState() != _audioStreamingState) {
                _hmiLevel = msg.getHmiLevel();
                _audioStreamingState = msg.getAudioStreamingState();
                if (_callbackToUIThread) {
                    _mainUIHandler.post(new Runnable() {
                        public void run() {
                            _proxyListener.onOnHMIStatus(msg);
                            _proxyListener.onOnLockScreenNotification(sdlSession.getLockScreenMan().getLockObj());
                            onRPCNotificationReceived(msg);
                        }
                    });
                } else {
                    _proxyListener.onOnHMIStatus(msg);
                    _proxyListener.onOnLockScreenNotification(sdlSession.getLockScreenMan().getLockObj());
                    onRPCNotificationReceived(msg);
                }
            }
        } else if (functionName.equals(FunctionID.ON_COMMAND.toString())) {
            final OnCommand msg = new OnCommand(hash);
            if (_callbackToUIThread) {
                _mainUIHandler.post(new Runnable() {
                    public void run() {
                        _proxyListener.onOnCommand(msg);
                        onRPCNotificationReceived(msg);
                    }
                });
            } else {
                _proxyListener.onOnCommand(msg);
                onRPCNotificationReceived(msg);
            }
        } else if (functionName.equals(FunctionID.ON_DRIVER_DISTRACTION.toString())) {
            final OnDriverDistraction msg = new OnDriverDistraction(hash);
            if (sdlSession != null) {
                DriverDistractionState drDist = msg.getState();
                sdlSession.getLockScreenMan().setDriverDistStatus(drDist == DriverDistractionState.DD_ON);
            }
            if (_callbackToUIThread) {
                _mainUIHandler.post(new Runnable() {
                    public void run() {
                        _proxyListener.onOnDriverDistraction(msg);
                        _proxyListener.onOnLockScreenNotification(sdlSession.getLockScreenMan().getLockObj());
                        onRPCNotificationReceived(msg);
                    }
                });
            } else {
                _proxyListener.onOnDriverDistraction(msg);
                _proxyListener.onOnLockScreenNotification(sdlSession.getLockScreenMan().getLockObj());
                onRPCNotificationReceived(msg);
            }
        } else if (functionName.equals(FunctionID.ON_ENCODED_SYNC_P_DATA.toString())) {
            final OnSystemRequest msg = new OnSystemRequest(hash);
            Intent sendIntent = createBroadcastIntent();
            updateBroadcastIntent(sendIntent, "String_Node_Str", FunctionID.ON_SYSTEM_REQUEST.toString());
            updateBroadcastIntent(sendIntent, "String_Node_Str", RPCMessage.KEY_NOTIFICATION);
            if (msg.getUrl() == null) {
                updateBroadcastIntent(sendIntent, "String_Node_Str", "String_Node_Str");
                sendBroadcastIntent(sendIntent);
                if (_callbackToUIThread) {
                    _mainUIHandler.post(new Runnable() {
                        public void run() {
                            _proxyListener.onOnSystemRequest(msg);
                            onRPCNotificationReceived(msg);
                        }
                    });
                } else {
                    _proxyListener.onOnSystemRequest(msg);
                    onRPCNotificationReceived(msg);
                }
            } else {
                updateBroadcastIntent(sendIntent, "String_Node_Str", "String_Node_Str" + msg.getUrl());
                sendBroadcastIntent(sendIntent);
                Log.i("String_Node_Str", "String_Node_Str");
                if ((msg.getUrl() != null)) {
                    Thread handleOffboardTransmissionThread = new Thread() {
                        public void run() {
                            sendOnSystemRequestToUrl(msg);
                        }
                    };
                    handleOffboardTransmissionThread.start();
                }
            }
        } else if (functionName.equals(FunctionID.ON_PERMISSIONS_CHANGE.toString())) {
            final OnPermissionsChange msg = new OnPermissionsChange(hash);
            if (_callbackToUIThread) {
                _mainUIHandler.post(new Runnable() {
                    public void run() {
                        _proxyListener.onOnPermissionsChange(msg);
                        onRPCNotificationReceived(msg);
                    }
                });
            } else {
                _proxyListener.onOnPermissionsChange(msg);
                onRPCNotificationReceived(msg);
            }
        } else if (functionName.equals(FunctionID.ON_TBT_CLIENT_STATE.toString())) {
            final OnTBTClientState msg = new OnTBTClientState(hash);
            if (_callbackToUIThread) {
                _mainUIHandler.post(new Runnable() {
                    public void run() {
                        _proxyListener.onOnTBTClientState(msg);
                        onRPCNotificationReceived(msg);
                    }
                });
            } else {
                _proxyListener.onOnTBTClientState(msg);
                onRPCNotificationReceived(msg);
            }
        } else if (functionName.equals(FunctionID.ON_BUTTON_PRESS.toString())) {
            final OnButtonPress msg = new OnButtonPress(hash);
            if (_callbackToUIThread) {
                _mainUIHandler.post(new Runnable() {
                    public void run() {
                        _proxyListener.onOnButtonPress(msg);
                        onRPCNotificationReceived(msg);
                    }
                });
            } else {
                _proxyListener.onOnButtonPress(msg);
                onRPCNotificationReceived(msg);
            }
        } else if (functionName.equals(FunctionID.ON_BUTTON_EVENT.toString())) {
            final OnButtonEvent msg = new OnButtonEvent(hash);
            if (_callbackToUIThread) {
                _mainUIHandler.post(new Runnable() {
                    public void run() {
                        _proxyListener.onOnButtonEvent(msg);
                        onRPCNotificationReceived(msg);
                    }
                });
            } else {
                _proxyListener.onOnButtonEvent(msg);
                onRPCNotificationReceived(msg);
            }
        } else if (functionName.equals(FunctionID.ON_LANGUAGE_CHANGE.toString())) {
            final OnLanguageChange msg = new OnLanguageChange(hash);
            if (_callbackToUIThread) {
                _mainUIHandler.post(new Runnable() {
                    public void run() {
                        _proxyListener.onOnLanguageChange(msg);
                        onRPCNotificationReceived(msg);
                    }
                });
            } else {
                _proxyListener.onOnLanguageChange(msg);
                onRPCNotificationReceived(msg);
            }
        } else if (functionName.equals(FunctionID.ON_HASH_CHANGE.toString())) {
            final OnHashChange msg = new OnHashChange(hash);
            if (_callbackToUIThread) {
                _mainUIHandler.post(new Runnable() {
                    public void run() {
                        _proxyListener.onOnHashChange(msg);
                        onRPCNotificationReceived(msg);
                        if (_bAppResumeEnabled) {
                            _lastHashID = msg.getHashID();
                        }
                    }
                });
            } else {
                _proxyListener.onOnHashChange(msg);
                onRPCNotificationReceived(msg);
                if (_bAppResumeEnabled) {
                    _lastHashID = msg.getHashID();
                }
            }
        } else if (functionName.equals(FunctionID.ON_SYSTEM_REQUEST.toString())) {
            final OnSystemRequest msg = new OnSystemRequest(hash);
            if ((msg.getUrl() != null) && (((msg.getRequestType() == RequestType.PROPRIETARY) && (msg.getFileType() == FileType.JSON)) || ((msg.getRequestType() == RequestType.HTTP) && (msg.getFileType() == FileType.BINARY)))) {
                Thread handleOffboardTransmissionThread = new Thread() {
                    public void run() {
                        sendOnSystemRequestToUrl(msg);
                    }
                };
                handleOffboardTransmissionThread.start();
            }
            if (msg.getRequestType() == RequestType.LOCK_SCREEN_ICON_URL && msg.getUrl() != null) {
                lockScreenIconRequest = msg;
            }
            if (_callbackToUIThread) {
                _mainUIHandler.post(new Runnable() {
                    public void run() {
                        _proxyListener.onOnSystemRequest(msg);
                        onRPCNotificationReceived(msg);
                    }
                });
            } else {
                _proxyListener.onOnSystemRequest(msg);
                onRPCNotificationReceived(msg);
            }
        } else if (functionName.equals(FunctionID.ON_AUDIO_PASS_THRU.toString())) {
            final OnAudioPassThru msg = new OnAudioPassThru(hash);
            if (_callbackToUIThread) {
                _mainUIHandler.post(new Runnable() {
                    public void run() {
                        _proxyListener.onOnAudioPassThru(msg);
                        onRPCNotificationReceived(msg);
                    }
                });
            } else {
                _proxyListener.onOnAudioPassThru(msg);
                onRPCNotificationReceived(msg);
            }
        } else if (functionName.equals(FunctionID.ON_VEHICLE_DATA.toString())) {
            final OnVehicleData msg = new OnVehicleData(hash);
            if (_callbackToUIThread) {
                _mainUIHandler.post(new Runnable() {
                    public void run() {
                        _proxyListener.onOnVehicleData(msg);
                        onRPCNotificationReceived(msg);
                    }
                });
            } else {
                _proxyListener.onOnVehicleData(msg);
                onRPCNotificationReceived(msg);
            }
        } else if (functionName.equals(FunctionID.ON_APP_INTERFACE_UNREGISTERED.toString())) {
            _appInterfaceRegisterd = false;
            synchronized (APP_INTERFACE_REGISTERED_LOCK) {
                APP_INTERFACE_REGISTERED_LOCK.notify();
            }
            final OnAppInterfaceUnregistered msg = new OnAppInterfaceUnregistered(hash);
            Intent sendIntent = createBroadcastIntent();
            updateBroadcastIntent(sendIntent, "String_Node_Str", FunctionID.ON_APP_INTERFACE_UNREGISTERED.toString());
            updateBroadcastIntent(sendIntent, "String_Node_Str", RPCMessage.KEY_NOTIFICATION);
            updateBroadcastIntent(sendIntent, "String_Node_Str", serializeJSON(msg));
            sendBroadcastIntent(sendIntent);
            if (_advancedLifecycleManagementEnabled) {
                cycleProxy(SdlDisconnectedReason.convertAppInterfaceUnregisteredReason(msg.getReason()));
            } else {
                if (_callbackToUIThread) {
                    _mainUIHandler.post(new Runnable() {
                        public void run() {
                            ((IProxyListener) _proxyListener).onOnAppInterfaceUnregistered(msg);
                            onRPCNotificationReceived(msg);
                        }
                    });
                } else {
                    ((IProxyListener) _proxyListener).onOnAppInterfaceUnregistered(msg);
                    onRPCNotificationReceived(msg);
                }
                notifyProxyClosed("String_Node_Str", null, SdlDisconnectedReason.APP_INTERFACE_UNREG);
            }
        } else if (functionName.equals(FunctionID.ON_KEYBOARD_INPUT.toString())) {
            final OnKeyboardInput msg = new OnKeyboardInput(hash);
            if (_callbackToUIThread) {
                _mainUIHandler.post(new Runnable() {
                    public void run() {
                        _proxyListener.onOnKeyboardInput(msg);
                        onRPCNotificationReceived(msg);
                    }
                });
            } else {
                _proxyListener.onOnKeyboardInput(msg);
                onRPCNotificationReceived(msg);
            }
        } else if (functionName.equals(FunctionID.ON_TOUCH_EVENT.toString())) {
            final OnTouchEvent msg = new OnTouchEvent(hash);
            if (_callbackToUIThread) {
                _mainUIHandler.post(new Runnable() {
                    public void run() {
                        _proxyListener.onOnTouchEvent(msg);
                        onRPCNotificationReceived(msg);
                    }
                });
            } else {
                _proxyListener.onOnTouchEvent(msg);
                onRPCNotificationReceived(msg);
            }
        } else if (functionName.equals(FunctionID.ON_WAY_POINT_CHANGE.toString())) {
            final OnWayPointChange msg = new OnWayPointChange(hash);
            if (_callbackToUIThread) {
                _mainUIHandler.post(new Runnable() {
                    public void run() {
                        _proxyListener.onOnWayPointChange(msg);
                        onRPCNotificationReceived(msg);
                    }
                });
            } else {
                _proxyListener.onOnWayPointChange(msg);
                onRPCNotificationReceived(msg);
            }
        } else if (functionName.equals(FunctionID.ON_INTERIOR_VEHICLE_DATA.toString())) {
            final OnInteriorVehicleData msg = new OnInteriorVehicleData(hash);
            if (_callbackToUIThread) {
                _mainUIHandler.post(new Runnable() {
                    public void run() {
                        _proxyListener.onOnInteriorVehicleData(msg);
                        onRPCNotificationReceived(msg);
                    }
                });
            } else {
                _proxyListener.onOnInteriorVehicleData(msg);
                onRPCNotificationReceived(msg);
            }
        } else {
            if (_sdlMsgVersion != null) {
                DebugTool.logInfo("String_Node_Str" + functionName + "String_Node_Str" + _sdlMsgVersion.getMajorVersion() + "String_Node_Str" + _sdlMsgVersion.getMinorVersion());
            } else {
                DebugTool.logInfo("String_Node_Str" + functionName);
            }
        }
    }
    SdlTrace.logProxyEvent("String_Node_Str" + functionName, SDL_LIB_TRACE_KEY);
}

Output:
                     _mainUIHandler.post(new Runnable() {
-                        public void run() {
-                            _proxyListener.onOnHMIStatus(msg);
-                            _proxyListener.onOnLockScreenNotification(sdlSession.getLockScreenMan().getLockObj());
-                            onRPCNotificationReceived(msg);
-                        }
-                    });
-                } else {
-                    _proxyListener.onOnHMIStatus(msg);
-                    _proxyListener.onOnLockScreenNotification(sdlSession.getLockScreenMan().getLockObj());
-                    onRPCNotificationReceived(msg);
-                }
+                    public void run() {
+                        _proxyListener.onOnHMIStatus(msg);
+                        _proxyListener.onOnLockScreenNotification(sdlSession.getLockScreenMan().getLockObj());
+                        onRPCNotificationReceived(msg);
+                    }
+                });
+            } else {
+                _proxyListener.onOnHMIStatus(msg);
+                _proxyListener.onOnLockScreenNotification(sdlSession.getLockScreenMan().getLockObj());
+                onRPCNotificationReceived(msg);
             }


Input:
public void testRecoverPresumedAbort() throws Exception {
    xaResource.addInDoubtXid(new MockXid(0, 0, BitronixXid.FORMAT_ID));
    xaResource.addInDoubtXid(new MockXid(1, 1, BitronixXid.FORMAT_ID));
    xaResource.addInDoubtXid(new MockXid(2, 2, BitronixXid.FORMAT_ID));
    TransactionManagerServices.getRecoverer().run();
    assertEquals(0, TransactionManagerServices.getRecoverer().getCommittedCount());
    assertEquals(3, TransactionManagerServices.getRecoverer().getRolledbackCount());
    assertEquals(0, xaResource.recover(XAResource.TMSTARTRSCAN | XAResource.TMENDRSCAN).length);
}

Output:
 public void testRecoverPresumedAbort() throws Exception {
-    xaResource.addInDoubtXid(new MockXid(0, 0, BitronixXid.FORMAT_ID));
-    xaResource.addInDoubtXid(new MockXid(1, 1, BitronixXid.FORMAT_ID));
-    xaResource.addInDoubtXid(new MockXid(2, 2, BitronixXid.FORMAT_ID));
+    byte[] gtrid = UidGenerator.generateUid().getArray();
+    xaResource.addInDoubtXid(new MockXid(0, gtrid, BitronixXid.FORMAT_ID));
+    xaResource.addInDoubtXid(new MockXid(1, gtrid, BitronixXid.FORMAT_ID));
+    xaResource.addInDoubtXid(new MockXid(2, gtrid, BitronixXid.FORMAT_ID));
     TransactionManagerServices.getRecoverer().run();


Input:
public void playerEggThrow(PlayerEggThrowEvent event) {
    Map<String, dObject> context = new HashMap<String, dObject>();
    dEntity egg = new dEntity(event.getEgg());
    context.put("String_Node_Str", egg);
    context.put("String_Node_Str", new Element(event.isHatching()));
    List<String> events = new ArrayList<String>();
    events.add("String_Node_Str");
    if (event.isHatching())
        events.add("String_Node_Str");
    else
        events.add("String_Node_Str");
    String determination = EventManager.doEvents(events, null, new dPlayer(event.getPlayer()), context);
    if (dEntity.matches(determination)) {
        event.setHatching(true);
        event.setHatchingType(dEntity.valueOf(determination).getEntityType());
    }
}

Output:
     String determination = EventManager.doEvents(events, null, new dPlayer(event.getPlayer()), context);
-    if (dEntity.matches(determination)) {
+    if (determination.equalsIgnoreCase("String_Node_Str")) {
+        event.setHatching(false);
+    } else if (dEntity.matches(determination)) {
         event.setHatching(true);


Input:
public void toBytes(ByteBuf buf) {
    buf.writeInt(getName().length());
    buf.writeBytes(getName().getBytes());
}

Output:
 public void toBytes(ByteBuf buf) {
-    buf.writeInt(getName().length());
-    buf.writeBytes(getName().getBytes());
+    NetworkTools.writeString(buf, getName());
 }


Input:
public ArrayList<String> getPropertys(String element) throws IOException {
    sendServerPropertyRequest(element);
    return do_parsing("String_Node_Str");
}

Output:
 public ArrayList<String> getPropertys(String element) throws IOException {
-    sendServerPropertyRequest(element);
-    return do_parsing("String_Node_Str");
+    try {
+        sendServerPropertyRequest(element);
+        return do_parsing("String_Node_Str");
+    } catch (Exception e) {
+        return null;
+    }
 }


Input:
private void initChannelPool() {
    Map<String, Config> clientConfigs = this.configManager.getClientConfigMap();
    ChannelPoolConfig config = new ChannelPoolConfig();
    config.setMaxTotal(Integer.valueOf(clientConfigs.get("String_Node_Str").getValue()));
    config.setMaxIdle(Integer.valueOf(clientConfigs.get("String_Node_Str").getValue()));
    config.setMaxWaitMillis(Long.valueOf(clientConfigs.get("String_Node_Str").getValue()));
    config.setTestOnBorrow(Boolean.valueOf(clientConfigs.get("String_Node_Str").getValue()));
    config.setTestOnReturn(Boolean.valueOf(clientConfigs.get("String_Node_Str").getValue()));
    pool = new ChannelPool(config, new ChannelFactory(this.connection));
}

Output:
     ChannelPoolConfig config = new ChannelPoolConfig();
-    config.setMaxTotal(Integer.valueOf(clientConfigs.get("String_Node_Str").getValue()));
-    config.setMaxIdle(Integer.valueOf(clientConfigs.get("String_Node_Str").getValue()));
-    config.setMaxWaitMillis(Long.valueOf(clientConfigs.get("String_Node_Str").getValue()));
+    config.setMaxTotal(Integer.parseInt(clientConfigs.get("String_Node_Str").getValue()));
+    config.setMaxIdle(Integer.parseInt(clientConfigs.get("String_Node_Str").getValue()));
+    config.setMaxWaitMillis(Long.parseLong(clientConfigs.get("String_Node_Str").getValue()));
     config.setTestOnBorrow(Boolean.valueOf(clientConfigs.get("String_Node_Str").getValue()));


Input:
protected String createUniqueName() {
    return String.format("String_Node_Str", this.loadbalancer.getDisplayName(), this.zoneName);
}

Output:
 protected String createUniqueName() {
-    return String.format("String_Node_Str", this.loadbalancer.getDisplayName(), this.zoneName);
+    return String.format("String_Node_Str", this.loadbalancer.getOwnerAccountNumber(), this.loadbalancer.getDisplayName(), this.zoneName);
 }


Input:
public void setUp() {
    parser = new FieldParser(FieldConstraintsBuilder.instance().createConstraintsInstance());
}

Output:
 public void setUp() {
-    parser = new FieldParser(FieldConstraintsBuilder.instance().createConstraintsInstance());
+    parser = new FieldParser(FieldConstraintsBuilder.instance().addHashSupport().createConstraintsInstance());
 }


Input:
private void doUTXOLookupsForPledges(Project project, ObservableSet<LHProtos.Pledge> pledges, List<Peer> peers, boolean checkingAllPledges, CompletableFuture<Set<LHProtos.Pledge>> result) {
    executor.checkOnThread();
    try {
        log.info("String_Node_Str", peers.size());
        PeerUTXOMultiplexor multiplexor = new PeerUTXOMultiplexor(peers);
        BatchingUTXOSource utxoSource = new BatchingUTXOSource(multiplexor);
        List<CompletableFuture<LHProtos.Pledge>> futures = new ArrayList<>(pledges.size());
        for (LHProtos.Pledge pledge : pledges) futures.add(project.verifyPledge(utxoSource, pledge));
        try {
            utxoSource.run();
            futureOfFutures(futures).get(10, TimeUnit.SECONDS);
        } catch (TimeoutException e) {
        }
        Set<TransactionOutPoint> allOutpoints = checkingAllPledges ? new HashSet<>() : getAllPledgedOutPointsFor(project);
        List<LHProtos.Pledge> verifiedPledges = new ArrayList<>(futures.size());
        for (CompletableFuture<LHProtos.Pledge> future : futures) {
            if (!future.isDone()) {
                log.warn("String_Node_Str", future);
                continue;
            }
            try {
                LHProtos.Pledge pledge = future.get();
                Transaction tx = project.fastSanityCheck(pledge);
                for (TransactionInput input : tx.getInputs()) {
                    if (allOutpoints.contains(input.getOutpoint()))
                        throw new ExecutionException(new VerificationException.DuplicatedOutPoint());
                    allOutpoints.add(input.getOutpoint());
                }
                verifiedPledges.add(pledge);
            } catch (ExecutionException e) {
                if (!(getRootCause(e) instanceof Ex.UnknownUTXO))
                    throw e;
            }
        }
        log.info("String_Node_Str", verifiedPledges.size(), pledges.size());
        syncPledges(project, pledges, verifiedPledges);
        refreshBloomFilter();
        markAsCheckDone(project);
        result.complete(new HashSet<>(verifiedPledges));
    } catch (InterruptedException | ExecutionException e) {
        log.error("String_Node_Str", e);
        markAsErrored(project, e);
        result.completeExceptionally(e);
    }
}

Output:
     try {
-        log.info("String_Node_Str", peers.size());
+        log.info("String_Node_Str", peers.size(), checkingAllPledges ? "String_Node_Str" : "String_Node_Str");
         PeerUTXOMultiplexor multiplexor = new PeerUTXOMultiplexor(peers);


Input:
private int indexOfFeedId(long feedId) {
    for (int i = 0; i < size(); i++) {
        if (this.get(i).feedId == feedId)
            return i;
    }
    return -1;
}

Output:
     for (int i = 0; i < size(); i++) {
-        if (this.get(i).feedId == feedId)
+        if (this.get(i).feedId == feedId) {
             return i;


Input:
public SqlQueryBuilder appendPathSegments(ContentUri.PathSegment[] pathSegments) {
    for (ContentUri.PathSegment pathSegment : pathSegments) {
        append(String.format("String_Node_Str", pathSegment.column(), pathSegment.segment()));
    }
    return this;
}

Output:
     for (ContentUri.PathSegment pathSegment : pathSegments) {
-        append(String.format("String_Node_Str", pathSegment.column(), pathSegment.segment()));
+        ColumnDefinition columnDefinition = tableDefinition.mColumnMap.get(pathSegment.column());
+        if (columnDefinition == null) {
+            processorManager.logError("String_Node_Str", pathSegment.column(), tableDefinition.tableName);
+        } else {
+            append(String.format("String_Node_Str", pathSegment.column()));
+            if (columnDefinition.element.asType().getKind().isPrimitive()) {
+                String name = columnDefinition.element.asType().toString();
+                name = name.substring(0, 1).toUpperCase() + name.substring(1);
+                append(String.format("String_Node_Str", name, pathSegment.segment()));
+            } else {
+                append(String.format("String_Node_Str", pathSegment.segment()));
+            }
+        }
     }


Input:
public void registerTypes() {
    SDOType stringType = (SDOType) typeHelper.getType(SDOConstants.SDO_URL, SDOConstants.STRING);
    SDOType bytesType = (SDOType) typeHelper.getType(SDOConstants.SDO_URL, SDOConstants.BYTES);
    SDOType propertyType = (SDOType) typeHelper.getType(SDOConstants.SDO_URL, SDOConstants.PROPERTY);
    DataObject customerType = dataFactory.create(SDOConstants.SDO_URL, SDOConstants.TYPE);
    customerType.set("String_Node_Str", getControlRootURI());
    customerType.set("String_Node_Str", "String_Node_Str");
    addProperty(customerType, "String_Node_Str", stringType, true, false, true);
    addProperty(customerType, "String_Node_Str", stringType, true, false, true);
    DataObject photoProp = addProperty(customerType, "String_Node_Str", bytesType, true, false, true);
    photoProp.set(SDOConstants.MIME_TYPE_PROPERTY_PROPERTY, "String_Node_Str");
    addProperty(customerType, "String_Node_Str", stringType, true, false, true);
    Type customerSDOType = typeHelper.define(customerType);
    DataObject propDO = dataFactory.create(propertyType);
    propDO.set("String_Node_Str", getControlRootName());
    propDO.set("String_Node_Str", customerSDOType);
    typeHelper.defineOpenContentProperty(getControlRootURI(), propDO);
}

Output:
     customerType.set("String_Node_Str", "String_Node_Str");
-    addProperty(customerType, "String_Node_Str", stringType, true, false, true);
-    addProperty(customerType, "String_Node_Str", stringType, true, false, true);
-    DataObject photoProp = addProperty(customerType, "String_Node_Str", bytesType, true, false, true);
+    addProperty(customerType, "String_Node_Str", stringType, false, false, true);
+    addProperty(customerType, "String_Node_Str", stringType, false, false, true);
+    DataObject photoProp = addProperty(customerType, "String_Node_Str", bytesType, false, false, true);
     photoProp.set(SDOConstants.MIME_TYPE_PROPERTY_PROPERTY, "String_Node_Str");


Input:
public void onReceive(Context context, Intent intent) {
    String action = intent.getAction();
    if (action.equals(Intent.ACTION_BOOT_COMPLETED)) {
        context.startService(new Intent(context, BluetoothOppService.class));
    } else if (action.equals(BluetoothIntent.BLUETOOTH_STATE_CHANGED_ACTION)) {
        if (BluetoothDevice.BLUETOOTH_STATE_ON == intent.getIntExtra(BluetoothIntent.BLUETOOTH_STATE, BluetoothError.ERROR)) {
            if (Constants.LOGVV) {
                Log.v(TAG, "String_Node_Str");
            }
            context.startService(new Intent(context, BluetoothOppService.class));
            synchronized (this) {
                if (BluetoothOppManager.getInstance(context).mSendingFlag) {
                    BluetoothOppManager.getInstance(context).mSendingFlag = false;
                    Intent in1 = new Intent(context, BluetoothDevicePickerActivity.class);
                    in1.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
                    context.startActivity(in1);
                }
            }
        }
    } else if (action.equals(BluetoothShare.BLUETOOTH_DEVICE_SELECTED_ACTION)) {
        BluetoothOppManager mOppManager = BluetoothOppManager.getInstance(context);
        String btAddr = (String) intent.getStringExtra("String_Node_Str");
        if (Constants.LOGVV) {
            Log.v(TAG, "String_Node_Str" + btAddr);
        }
        mOppManager.startTransfer(btAddr);
        String deviceName = mOppManager.getDeviceName(btAddr);
        String toastMsg;
        if (mOppManager.mMultipleFlag) {
            toastMsg = context.getString(R.string.bt_toast_5, Integer.toString(mOppManager.mfileNumInBatch), deviceName);
        } else {
            toastMsg = context.getString(R.string.bt_toast_4, deviceName);
        }
        Toast.makeText(context, toastMsg, Toast.LENGTH_SHORT).show();
    } else if (action.equals(Constants.ACTION_INCOMING_FILE_CONFIRM)) {
        if (Constants.LOGVV) {
            Log.v(TAG, "String_Node_Str");
        }
        Uri uri = intent.getData();
        Intent in = new Intent(context, BluetoothOppIncomingFileConfirmActivity.class);
        in.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
        in.setData(uri);
        context.startActivity(in);
        NotificationManager notMgr = (NotificationManager) context.getSystemService(Context.NOTIFICATION_SERVICE);
        if (notMgr != null) {
            notMgr.cancel((int) ContentUris.parseId(intent.getData()));
            Log.v(TAG, "String_Node_Str");
        }
    } else if (action.equals(BluetoothShare.INCOMING_FILE_CONFIRMATION_REQUEST_ACTION)) {
        if (Constants.LOGVV) {
            Log.v(TAG, "String_Node_Str");
        }
        Toast.makeText(context, context.getString(R.string.incoming_file_toast_msg), Toast.LENGTH_SHORT).show();
    } else if (action.equals(Constants.ACTION_OPEN) || action.equals(Constants.ACTION_LIST)) {
        if (Constants.LOGVV) {
            if (action.equals(Constants.ACTION_OPEN)) {
                Log.v(TAG, "String_Node_Str" + intent.getData());
            } else {
                Log.v(TAG, "String_Node_Str" + intent.getData());
            }
        }
        BluetoothOppTransferInfo transInfo = new BluetoothOppTransferInfo();
        Uri uri = intent.getData();
        transInfo = BluetoothOppUtility.queryRecord(context, uri);
        if (transInfo == null) {
            if (Constants.LOGVV) {
                Log.e(TAG, "String_Node_Str");
            }
            return;
        }
        if (transInfo.mDirection == BluetoothShare.DIRECTION_INBOUND && BluetoothShare.isStatusSuccess(transInfo.mStatus)) {
            BluetoothOppUtility.openReceivedFile(context, transInfo.mFileName, transInfo.mFileType, transInfo.mTimeStamp);
            BluetoothOppUtility.updateVisibilityToHidden(context, uri);
        } else {
            Intent in = new Intent(context, BluetoothOppTransferActivity.class);
            in.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
            in.setData(uri);
            context.startActivity(in);
        }
        NotificationManager notMgr = (NotificationManager) context.getSystemService(Context.NOTIFICATION_SERVICE);
        if (notMgr != null) {
            notMgr.cancel((int) ContentUris.parseId(intent.getData()));
            Log.v(TAG, "String_Node_Str");
        }
    } else if (action.equals(Constants.ACTION_HIDE)) {
        if (Constants.LOGVV) {
            Log.v(TAG, "String_Node_Str" + intent.getData());
        }
        Cursor cursor = context.getContentResolver().query(intent.getData(), null, null, null, null);
        if (cursor != null) {
            if (cursor.moveToFirst()) {
                int statusColumn = cursor.getColumnIndexOrThrow(BluetoothShare.STATUS);
                int status = cursor.getInt(statusColumn);
                int visibilityColumn = cursor.getColumnIndexOrThrow(BluetoothShare.VISIBILITY);
                int visibility = cursor.getInt(visibilityColumn);
                int userConfirmationColumn = cursor.getColumnIndexOrThrow(BluetoothShare.USER_CONFIRMATION);
                int userConfirmation = cursor.getInt(userConfirmationColumn);
                if ((BluetoothShare.isStatusCompleted(status) || (userConfirmation == BluetoothShare.USER_CONFIRMATION_PENDING)) && visibility == BluetoothShare.VISIBILITY_VISIBLE) {
                    ContentValues values = new ContentValues();
                    values.put(BluetoothShare.VISIBILITY, BluetoothShare.VISIBILITY_HIDDEN);
                    context.getContentResolver().update(intent.getData(), values, null, null);
                    if (Constants.LOGVV) {
                        Log.v(TAG, "String_Node_Str");
                    }
                }
            }
            cursor.close();
        }
    } else if (action.equals(BluetoothShare.TRANSFER_COMPLETED_ACTION)) {
        if (Constants.LOGVV) {
            Log.v(TAG, "String_Node_Str" + intent.getData());
        }
        String toastMsg = null;
        BluetoothOppTransferInfo transInfo = new BluetoothOppTransferInfo();
        transInfo = BluetoothOppUtility.queryRecord(context, intent.getData());
        if (transInfo == null) {
            if (Constants.LOGVV) {
                Log.e(TAG, "String_Node_Str");
            }
            return;
        }
        if (BluetoothShare.isStatusSuccess(transInfo.mStatus)) {
            if (transInfo.mDirection == BluetoothShare.DIRECTION_OUTBOUND) {
                toastMsg = context.getString(R.string.notification_sent, transInfo.mFileName);
            } else if (transInfo.mDirection == BluetoothShare.DIRECTION_INBOUND) {
                toastMsg = context.getString(R.string.notification_received, transInfo.mFileName);
            }
        } else if (BluetoothShare.isStatusError(transInfo.mStatus)) {
            if (transInfo.mDirection == BluetoothShare.DIRECTION_OUTBOUND) {
                toastMsg = context.getString(R.string.notification_sent_fail, transInfo.mFileName);
            } else if (transInfo.mDirection == BluetoothShare.DIRECTION_INBOUND) {
                toastMsg = context.getString(R.string.download_fail_line1);
            }
        }
        if (Constants.LOGVV) {
            Log.v(TAG, "String_Node_Str" + toastMsg);
        }
        if (toastMsg != null) {
            Toast.makeText(context, toastMsg, Toast.LENGTH_SHORT).show();
        }
    }
}

Output:
             notMgr.cancel((int) ContentUris.parseId(intent.getData()));
-            Log.v(TAG, "String_Node_Str");
+            if (Constants.LOGVV) {
+                Log.v(TAG, "String_Node_Str");
+            }
         }


Input:
boolean unifyWithSubtype(NominalType other, List<String> typeParameters, Multimap<String, JSType> typeMultimap) {
    other = other.findMatchingAncestorWith(this);
    if (other == null) {
        return false;
    }
    if (!isGeneric()) {
        return true;
    }
    Preconditions.checkState(!typeMap.isEmpty());
    if (other.typeMap.isEmpty()) {
        return true;
    }
    boolean hasUnified = true;
    for (String typeParam : this.rawType.typeParameters) {
        JSType fromOtherMap = other.typeMap.get(typeParam);
        Preconditions.checkNotNull(fromOtherMap, "String_Node_Str", typeParam, other.typeMap);
        hasUnified = hasUnified && this.typeMap.get(typeParam).unifyWithSubtype(fromOtherMap, typeParameters, typeMultimap);
    }
    return hasUnified && isInvariantWith(typeMultimap, other);
}

Output:
     }
-    return hasUnified && isInvariantWith(typeMultimap, other);
+    return hasUnified && (allowCovariantGenerics(this) || isInvariantWith(typeMultimap, other));
 }


Input:
public void checkPrivileges(HiveOperationType hiveOpType, List<HivePrivilegeObject> inputHObjs, List<HivePrivilegeObject> outputHObjs, HiveAuthzContext context) throws HiveAuthzPluginException, HiveAccessControlException {
    UserGroupInformation ugi = getCurrentUserGroupInfo();
    if (ugi == null) {
        throw new HiveAccessControlException("String_Node_Str");
    }
    RangerHiveAuditHandler auditHandler = new RangerHiveAuditHandler();
    try {
        HiveAuthzSessionContext sessionContext = getHiveAuthzSessionContext();
        String user = ugi.getShortUserName();
        Set<String> groups = Sets.newHashSet(ugi.getGroupNames());
        if (LOG.isDebugEnabled()) {
            LOG.debug(toString(hiveOpType, inputHObjs, outputHObjs, context, sessionContext));
        }
        if (hiveOpType == HiveOperationType.DFS) {
            handleDfsCommand(hiveOpType, inputHObjs, outputHObjs, context, sessionContext, user, groups, auditHandler);
            return;
        }
        List<RangerHiveAccessRequest> requests = new ArrayList<RangerHiveAccessRequest>();
        if (inputHObjs != null) {
            for (HivePrivilegeObject hiveObj : inputHObjs) {
                RangerHiveResource resource = getHiveResource(hiveOpType, hiveObj);
                if (resource.getObjectType() == HiveObjectType.URI) {
                    String path = hiveObj.getObjectName();
                    FsAction permission = FsAction.READ;
                    if (!isURIAccessAllowed(user, groups, permission, path, getHiveConf())) {
                        throw new HiveAccessControlException(String.format("String_Node_Str", user, permission.name(), path));
                    }
                    continue;
                }
                HiveAccessType accessType = getAccessType(hiveObj, hiveOpType, true);
                if (accessType == HiveAccessType.NONE) {
                    continue;
                }
                if (!existsByResourceAndAccessType(requests, resource, accessType)) {
                    RangerHiveAccessRequest request = new RangerHiveAccessRequest(resource, user, groups, hiveOpType, accessType, context, sessionContext);
                    requests.add(request);
                }
            }
        }
        if (outputHObjs != null) {
            for (HivePrivilegeObject hiveObj : outputHObjs) {
                RangerHiveResource resource = getHiveResource(hiveOpType, hiveObj);
                if (resource.getObjectType() == HiveObjectType.URI) {
                    String path = hiveObj.getObjectName();
                    FsAction permission = FsAction.WRITE;
                    if (!isURIAccessAllowed(user, groups, permission, path, getHiveConf())) {
                        throw new HiveAccessControlException(String.format("String_Node_Str", user, permission.name(), path));
                    }
                    continue;
                }
                HiveAccessType accessType = getAccessType(hiveObj, hiveOpType, false);
                if (accessType == HiveAccessType.NONE) {
                    continue;
                }
                if (!existsByResourceAndAccessType(requests, resource, accessType)) {
                    RangerHiveAccessRequest request = new RangerHiveAccessRequest(resource, user, groups, hiveOpType, accessType, context, sessionContext);
                    requests.add(request);
                }
            }
        }
        if (isMetaDataOperation(hiveOpType)) {
            RangerHiveResource resource = getHiveResource(hiveOpType);
            RangerHiveAccessRequest request = new RangerHiveAccessRequest(resource, user, groups, context, sessionContext);
            RangerAccessResult result = hivePlugin.isAccessAllowed(request);
            if (result == null) {
                LOG.error("String_Node_Str");
                throw new HiveAccessControlException(String.format("String_Node_Str", user, hiveOpType));
            } else if (!result.getIsAllowed()) {
                String path = resource.getAsString(result.getServiceDef());
                throw new HiveAccessControlException(String.format("String_Node_Str", user, hiveOpType.name(), path));
            } else {
                if (LOG.isDebugEnabled()) {
                    LOG.debug(String.format("String_Node_Str", hiveOpType, resource, request, result));
                }
                if (result.getIsAudited()) {
                    auditHandler.logAuditEventForFiltering(result, hiveOpType);
                }
            }
        } else {
            for (RangerHiveAccessRequest request : requests) {
                RangerHiveResource resource = (RangerHiveResource) request.getResource();
                RangerAccessResult result = null;
                if (resource.getObjectType() == HiveObjectType.COLUMN && StringUtils.contains(resource.getColumn(), COLUMN_SEP)) {
                    List<RangerAccessRequest> colRequests = new ArrayList<RangerAccessRequest>();
                    String[] columns = StringUtils.split(resource.getColumn(), COLUMN_SEP);
                    for (String column : columns) {
                        if (column != null) {
                            column = column.trim();
                        }
                        if (StringUtils.isEmpty(column.trim())) {
                            continue;
                        }
                        RangerHiveResource colResource = new RangerHiveResource(HiveObjectType.COLUMN, resource.getDatabase(), resource.getTable(), column);
                        RangerHiveAccessRequest colRequest = request.copy();
                        colRequest.setResource(colResource);
                        colRequests.add(colRequest);
                    }
                    Collection<RangerAccessResult> colResults = hivePlugin.isAccessAllowed(colRequests, auditHandler);
                    if (colResults != null) {
                        for (RangerAccessResult colResult : colResults) {
                            result = colResult;
                            if (!result.getIsAllowed()) {
                                break;
                            }
                        }
                    }
                } else {
                    result = hivePlugin.isAccessAllowed(request, auditHandler);
                }
                if (result != null && !result.getIsAllowed()) {
                    String path = resource != null ? resource.getAsString(result.getServiceDef()) : null;
                    throw new HiveAccessControlException(String.format("String_Node_Str", user, request.getHiveAccessType().name(), path));
                }
            }
        }
    } finally {
        auditHandler.flushAudit();
    }
}

Output:
                         }
-                        if (StringUtils.isEmpty(column.trim())) {
+                        if (StringUtils.isEmpty(column)) {
                             continue;


Input:
public Map<String, Node> discoverNodes(List<ConnectionDetails> connectionDetailsList) {
    this.filter = filter;
    Map<String, Node> nodes = new HashMap<String, Node>();
    doDiscoverNodes(connectionDetailsList, nodes, null);
    return nodes;
}

Output:
     Map<String, Node> nodes = new HashMap<String, Node>();
-    doDiscoverNodes(connectionDetailsList, nodes, null);
+    doDiscoverNodes(connectionDetailsList, nodes, null, 0, depth);
     return nodes;


Input:
public void testCreateConsumer_InvalidCommitOffsetsInterval() throws Exception {
    final ConsumerConfig consumerConfig = new ConsumerConfig();
    consumerConfig.setGroup("String_Node_Str");
    consumerConfig.setCommitOffsetPeriodInMills(-1);
    final MessageConsumer messageConsumer = this.messageSessionFactory.createConsumer(consumerConfig);
}

Output:
     consumerConfig.setCommitOffsetPeriodInMills(-1);
-    final MessageConsumer messageConsumer = this.messageSessionFactory.createConsumer(consumerConfig);
+    final MessageConsumer messageConsumer = messageSessionFactory.createConsumer(consumerConfig);
 }


Input:
private void testFactTableSaveAndLoad1(IDocumentManager documentManager) throws IOException, BirtException {
    Dimension[] dimensions = new Dimension[3];
    ILevelDefn[] levelDefs = new ILevelDefn[1];
    String[] levelNames = new String[1];
    levelNames[0] = "String_Node_Str";
    DimensionForTest iterator = new DimensionForTest(levelNames);
    iterator.setLevelMember(0, distinct(LevelsAndFactTableDataset.dimension1Col));
    levelDefs[0] = new LevelDefinition("String_Node_Str", new String[] { "String_Node_Str" }, null);
    dimensions[0] = (Dimension) DimensionFactory.createDimension("String_Node_Str", documentManager, iterator, levelDefs, false, new StopSign());
    IHierarchy hierarchy = dimensions[0].getHierarchy();
    assertEquals(hierarchy.getName(), "String_Node_Str");
    levelNames = new String[1];
    levelNames[0] = "String_Node_Str";
    iterator = new DimensionForTest(levelNames);
    iterator.setLevelMember(0, distinct(LevelsAndFactTableDataset.dimension2Col));
    levelDefs[0] = new LevelDefinition("String_Node_Str", new String[] { "String_Node_Str" }, null);
    dimensions[1] = (Dimension) DimensionFactory.createDimension("String_Node_Str", documentManager, iterator, levelDefs, false, new StopSign());
    hierarchy = dimensions[1].getHierarchy();
    assertEquals(hierarchy.getName(), "String_Node_Str");
    levelNames = new String[1];
    levelNames[0] = "String_Node_Str";
    iterator = new DimensionForTest(levelNames);
    iterator.setLevelMember(0, distinct(LevelsAndFactTableDataset.dimension3Col));
    levelDefs[0] = new LevelDefinition("String_Node_Str", new String[] { "String_Node_Str" }, null);
    dimensions[2] = (Dimension) DimensionFactory.createDimension("String_Node_Str", documentManager, iterator, levelDefs, false, new StopSign());
    hierarchy = dimensions[2].getHierarchy();
    assertEquals(hierarchy.getName(), "String_Node_Str");
    IDatasetIterator factTableIterator = new LevelsAndFactTableDataset();
    String[] measureColumnName = new String[2];
    measureColumnName[0] = "String_Node_Str";
    measureColumnName[1] = "String_Node_Str";
    FactTableAccessor factTableConstructor = new FactTableAccessor(documentManager);
    FactTable factTable = factTableConstructor.saveFactTable(NamingUtil.getFactTableName("String_Node_Str"), CubeUtility.getKeyColNames(dimensions), CubeUtility.getKeyColNames(dimensions), factTableIterator, dimensions, measureColumnName, new StopSign(), false);
    assertEquals(factTable.getSegmentCount(), 1);
    factTable = factTableConstructor.load(NamingUtil.getFactTableName("String_Node_Str"), new StopSign());
    assertEquals(factTable.getSegmentCount(), 1);
    assertEquals(factTable.getDimensionInfo()[0].getDimensionName(), "String_Node_Str");
    assertEquals(factTable.getDimensionInfo()[0].getDimensionLength(), 3);
    assertEquals(factTable.getDimensionInfo()[1].getDimensionName(), "String_Node_Str");
    assertEquals(factTable.getDimensionInfo()[1].getDimensionLength(), 7);
    assertEquals(factTable.getDimensionInfo()[2].getDimensionName(), "String_Node_Str");
    assertEquals(factTable.getDimensionInfo()[2].getDimensionLength(), 14);
    assertEquals(factTable.getMeasureInfo()[0].getMeasureName(), "String_Node_Str");
    assertEquals(factTable.getMeasureInfo()[0].getDataType(), DataType.INTEGER_TYPE);
    assertEquals(factTable.getMeasureInfo()[1].getMeasureName(), "String_Node_Str");
    assertEquals(factTable.getMeasureInfo()[1].getDataType(), DataType.DOUBLE_TYPE);
    String[] dimensionNames = new String[1];
    dimensionNames[0] = "String_Node_Str";
    IDiskArray[] dimensionPosition = new IDiskArray[1];
    dimensionPosition[0] = new BufferedPrimitiveDiskArray();
    dimensionPosition[0].add(new Integer(1));
    dimensionPosition[0].add(new Integer(2));
    IFactTableRowIterator facttableRowIterator = new FactTableRowIterator(factTable, dimensionNames, dimensionPosition, new StopSign());
    facttableRowIterator = new FactTableRowIteratorWithFilter(dimensions, facttableRowIterator, new StopSign());
    assertTrue(facttableRowIterator != null);
    assertTrue(facttableRowIterator.next());
    assertEquals(0, facttableRowIterator.getDimensionPosition(0));
    assertEquals(1, facttableRowIterator.getDimensionPosition(1));
    assertEquals(3, facttableRowIterator.getDimensionPosition(2));
    assertEquals(new Integer(121), facttableRowIterator.getMeasure(0));
    assertEquals(new Double(121), facttableRowIterator.getMeasure(1));
    assertTrue(facttableRowIterator.next());
    assertEquals(0, facttableRowIterator.getDimensionPosition(0));
    assertEquals(1, facttableRowIterator.getDimensionPosition(1));
    assertEquals(4, facttableRowIterator.getDimensionPosition(2));
    assertEquals(new Integer(122), facttableRowIterator.getMeasure(0));
    assertEquals(new Double(122), facttableRowIterator.getMeasure(1));
    assertTrue(facttableRowIterator.next());
    assertEquals(1, facttableRowIterator.getDimensionPosition(0));
    assertEquals(2, facttableRowIterator.getDimensionPosition(1));
    assertEquals(5, facttableRowIterator.getDimensionPosition(2));
    assertEquals(new Integer(211), facttableRowIterator.getMeasure(0));
    assertEquals(new Double(211), facttableRowIterator.getMeasure(1));
    assertTrue(facttableRowIterator.next());
    assertEquals(1, facttableRowIterator.getDimensionPosition(0));
    assertEquals(2, facttableRowIterator.getDimensionPosition(1));
    assertEquals(6, facttableRowIterator.getDimensionPosition(2));
    assertEquals(new Integer(212), facttableRowIterator.getMeasure(0));
    assertEquals(new Double(212), facttableRowIterator.getMeasure(1));
    assertFalse(facttableRowIterator.next());
    facttableRowIterator.close();
}

Output:
     FactTableAccessor factTableConstructor = new FactTableAccessor(documentManager);
-    FactTable factTable = factTableConstructor.saveFactTable(NamingUtil.getFactTableName("String_Node_Str"), CubeUtility.getKeyColNames(dimensions), CubeUtility.getKeyColNames(dimensions), factTableIterator, dimensions, measureColumnName, new StopSign(), false);
+    FactTable factTable = factTableConstructor.saveFactTable(NamingUtil.getFactTableName("String_Node_Str"), CubeUtility.getKeyColNames(dimensions), CubeUtility.getKeyColNames(dimensions), factTableIterator, dimensions, measureColumnName, new StopSign());
     assertEquals(factTable.getSegmentCount(), 1);


Input:
protected <T> Request updateEdgeRequest(final String key, final T value, final EdgeUpdateOptions options) {
    final Request request;
    request = new Request(db, RequestType.PATCH, executor.createPath(ArangoDBConstants.PATH_API_GHARIAL, graph, ArangoDBConstants.EDGE, createDocumentHandle(key)));
    final EdgeUpdateOptions params = (options != null ? options : new EdgeUpdateOptions());
    request.putQueryParam(ArangoDBConstants.KEEP_NULL, params.getKeepNull());
    request.putQueryParam(ArangoDBConstants.WAIT_FOR_SYNC, params.getWaitForSync());
    request.putHeaderParam(ArangoDBConstants.IF_MATCH, params.getIfMatch());
    request.setBody(executor.serialize(value, true));
    return request;
}

Output:
     final Request request;
-    request = new Request(db, RequestType.PATCH, executor.createPath(ArangoDBConstants.PATH_API_GHARIAL, graph, ArangoDBConstants.EDGE, createDocumentHandle(key)));
+    request = new Request(db, RequestType.PATCH, executor.createPath(ArangoDBConstants.PATH_API_GHARIAL, graph, ArangoDBConstants.EDGE, executor.createDocumentHandle(name, key)));
     final EdgeUpdateOptions params = (options != null ? options : new EdgeUpdateOptions());