/** If the update was successful restart the MainActivity */ @Override protected void onPostExecute(String result) { super.onPostExecute(result); progr_dlg.dismiss(); // After all the update is (succesfully) done we have to restart // the main activity if (DONE.equals(result)) { // either we were started tru intent (return to main) if (context instanceof PreferencesActivity) { Activity a = (Activity) context; a.setResult(PreferencesActivity.RESULT_DATA_UPDATED); // this will call on activity result a.finish(); } // or directly by passing context: restart directly if (context instanceof MainActivity) { MainActivity mainActivity = (MainActivity) context; mainActivity.restartActivity(0); } } }
/** {@inheritDoc} */ @Override @NotNull public String getTimeout() { if (!(DONE.equals(status) || RUNNING.equals(status))) { return TIMER_STUB; } RunnerMetric timeoutMetric = getRunnerMetricByName(RunnerMetric.TERMINATION_TIME); if (timeoutMetric != null) { return getTimeOut(timeoutMetric); } RunnerMetric lifeTimeMetric = getRunnerMetricByName(RunnerMetric.LIFETIME); if (lifeTimeMetric != null && NEW.equals(descriptor.getStatus())) { return getLifeTime(lifeTimeMetric); } return TIMER_STUB; }
/** * Launches a group of 2 * getMaxActive() threads, each of which will attempt to obtain a * connection from the pool, hold it for <holdTime> ms, and then return it to the pool. If * <loopOnce> is false, threads will continue this process indefinitely. If <expectError> is true, * exactly 1/2 of the threads are expected to either throw exceptions or fail to complete. If * <expectError> is false, all threads are expected to complete successfully. * * @param holdTime time in ms that a thread holds a connection before returning it to the pool * @param expectError whether or not an error is expected * @param loopOnce whether threads should complete the borrow - hold - return cycle only once, or * loop indefinitely * @param maxWait passed in by client - has no impact on the test itself, but does get reported * @throws Exception */ protected void multipleThreads( final int holdTime, final boolean expectError, final boolean loopOnce, final long maxWait) throws Exception { long startTime = timeStamp(); final PoolTest[] pts = new PoolTest[2 * getMaxActive()]; // Catch Exception so we can stop all threads if one fails ThreadGroup threadGroup = new ThreadGroup("foo") { public void uncaughtException(Thread t, Throwable e) { for (int i = 0; i < pts.length; i++) { pts[i].stop(); } } }; // Create all the threads for (int i = 0; i < pts.length; i++) { pts[i] = new PoolTest(threadGroup, holdTime, expectError, loopOnce); } // Start all the threads for (int i = 0; i < pts.length; i++) { pts[i].start(); } // Give all threads a chance to start and succeed Thread.sleep(300L); // Stop threads for (int i = 0; i < pts.length; i++) { pts[i].stop(); } /* * Wait for all threads to terminate. * This is essential to ensure that all threads have a chance to update success[0] * and to ensure that the variable is published correctly. */ int done = 0; int failed = 0; int didNotRun = 0; int loops = 0; for (int i = 0; i < pts.length; i++) { final PoolTest poolTest = pts[i]; poolTest.thread.join(); loops += poolTest.loops; final String state = poolTest.state; if (DONE.equals(state)) { done++; } if (poolTest.loops == 0) { didNotRun++; } final Throwable thrown = poolTest.thrown; if (thrown != null) { failed++; if (!expectError || !(thrown instanceof SQLException)) { System.out.println("Unexpected error: " + thrown.getMessage()); } } } long time = timeStamp() - startTime; System.out.println( "Multithread test time = " + time + " ms. Threads: " + pts.length + ". Loops: " + loops + ". Hold time: " + holdTime + ". Maxwait: " + maxWait + ". Done: " + done + ". Did not run: " + didNotRun + ". Failed: " + failed + ". expectError: " + expectError); if (expectError) { if (DISPLAY_THREAD_DETAILS || (pts.length / 2 != failed)) { long offset = pts[0].created - 1000; // To reduce size of output numbers, but ensure they have 4 digits System.out.println("Offset: " + offset); for (int i = 0; i < pts.length; i++) { PoolTest pt = pts[i]; System.out.println( "Pre: " + (pt.preconnected - offset) // First, so can sort on this easily + ". Post: " + (pt.postconnected != 0 ? Long.toString(pt.postconnected - offset) : "-") + ". Hash: " + pt.connHash + ". Startup: " + (pt.started - pt.created) + ". getConn(): " + (pt.connected != 0 ? Long.toString(pt.connected - pt.preconnected) : "-") + ". Runtime: " + (pt.ended - pt.started) + ". IDX: " + i + ". Loops: " + pt.loops + ". State: " + pt.state + ". thrown: " + pt.thrown + "."); } } if (didNotRun > 0) { System.out.println("NOTE: some threads did not run the code: " + didNotRun); } // Perform initial sanity check: assertTrue("Expected some of the threads to fail", failed > 0); // Assume that threads that did not run would have timed out. assertEquals( "WARNING: Expected half the threads to fail", pts.length / 2, failed + didNotRun); } else { assertEquals("Did not expect any threads to fail", 0, failed); } }