private static boolean sleepIfNeeded() {
if (HeavyProcessLatch.INSTANCE.isInsideLowPriorityThread()) {
TimeoutUtil.sleep(1);
return true;
}
return false;
}
public void testDelayedTasksThatFiredAtTheSameTimeAreExecutedConcurrently()
throws InterruptedException, ExecutionException {
final AppScheduledExecutorService service = new AppScheduledExecutorService(getName());
final List<LogInfo> log = Collections.synchronizedList(new ArrayList<>());
int delay = 500;
int N = 20;
List<? extends Future<?>> futures =
ContainerUtil.map(
Collections.nCopies(N, ""),
__ ->
service.schedule(
() -> {
log.add(new LogInfo(0));
TimeoutUtil.sleep(10 * 1000);
},
delay,
TimeUnit.MILLISECONDS));
for (Future<?> future : futures) {
future.get();
}
assertEquals(N, log.size());
Set<Thread> usedThreads = ContainerUtil.map2Set(log, logInfo -> logInfo.currentThread);
assertEquals(N, usedThreads.size());
service.shutdownAppScheduledExecutorService();
assertTrue(service.awaitTermination(10, TimeUnit.SECONDS));
}
private static void runIndeterminateProgress(ProgressIndicator indicator) {
indicator.setIndeterminate(true);
indicator.setText("Indeterminate");
for (int i = 0; i < 200; i++) {
TimeoutUtil.sleep(10);
indicator.checkCanceled();
}
}
private static void runDeterminateProgress(ProgressIndicator indicator) {
int iterations = 3000;
for (int i = 0; i < iterations; i++) {
TimeoutUtil.sleep(1);
indicator.setFraction(((double) i + 1) / ((double) iterations));
indicator.setText(String.valueOf(i));
ProgressManager.checkCanceled();
}
}
public void testStatusDoesNotLockForWrite() throws Exception {
final File ioFile = new File(myWorkingCopyRoot, filename);
ioFile.getParentFile().mkdirs();
/*SVNWCClient client11 = new SVNWCClient((ISVNRepositoryPool)null, new DefaultSVNOptions());
client11.doAdd(ioFile.getParentFile(), true, false, true, true);*/
ioFile.createNewFile();
try {
final SVNStatusClient readClient =
new SVNStatusClient((ISVNRepositoryPool) null, new DefaultSVNOptions());
final Semaphore semaphore = new Semaphore();
final Semaphore semaphoreMain = new Semaphore();
final Semaphore semaphoreWokeUp = new Semaphore();
final AtomicReference<Boolean> wasUp = new AtomicReference<Boolean>(false);
final ISVNStatusHandler handler =
status -> {
semaphore.waitFor();
wasUp.set(true);
};
semaphore.down();
semaphoreMain.down();
semaphoreWokeUp.down();
final SVNException[] exception = new SVNException[1];
Thread thread =
new Thread(
() -> {
try {
semaphoreMain.up();
readClient.doStatus(myWorkingCopyRoot, true, false, true, false, handler);
semaphoreWokeUp.up();
} catch (SVNException e) {
exception[0] = e;
}
},
"svn test");
thread.start();
semaphoreMain.waitFor();
TimeoutUtil.sleep(5);
SVNWCClient client = new SVNWCClient((ISVNRepositoryPool) null, new DefaultSVNOptions());
client.doAdd(ioFile.getParentFile(), true, false, true, true);
semaphore.up();
semaphoreWokeUp.waitFor();
Assert.assertEquals(true, wasUp.get().booleanValue());
if (exception[0] != null) {
throw exception[0];
}
thread.join();
} finally {
ioFile.delete();
}
}
public void run() {
try {
while (readAvailable()) {
TimeoutUtil.sleep(50L);
}
} catch (Exception e) {
LOG.error(e);
}
}
public synchronized void close() throws IOException {
if (myWaitForThreadFuture != null) {
myWaitForThreadFuture.cancel(true);
}
if (myWaitSemaphore != null) {
myWaitSemaphore.up();
}
try {
if (myInputStream != null && !myContainsError) {
myInputStream.close();
TimeoutUtil.sleep(10);
}
} finally {
try {
if (myOutputStream != null && !myContainsError) {
myOutputStream.close();
TimeoutUtil.sleep(10);
}
try {
if (myErrThread != null) {
myErrThread.setProcessTerminated(true);
}
if (myStdErrFuture != null) {
myStdErrFuture.get();
}
} catch (InterruptedException e) {
//
} catch (ExecutionException e) {
LOG.error(e);
}
} finally {
try {
if (myProcess != null) {
myProcess.destroy();
}
} finally {
myInputStream = null;
myOutputStream = null;
myProcess = null;
}
}
}
}
public void testAwaitTerminationMakesSureTasksTransferredToBackendExecutorAreFinished()
throws InterruptedException, ExecutionException {
final AppScheduledExecutorService service = new AppScheduledExecutorService(getName());
final List<LogInfo> log = Collections.synchronizedList(new ArrayList<>());
int N = 20;
int delay = 500;
List<? extends Future<?>> futures =
ContainerUtil.map(
Collections.nCopies(N, ""),
s ->
service.schedule(
() -> {
TimeoutUtil.sleep(5000);
log.add(new LogInfo(0));
},
delay,
TimeUnit.MILLISECONDS));
TimeoutUtil.sleep(delay);
long start = System.currentTimeMillis();
while (!service.delayQueue.isEmpty() && System.currentTimeMillis() < start + 20000) {
// wait till all tasks transferred to backend
}
List<SchedulingWrapper.MyScheduledFutureTask> queuedTasks = new ArrayList<>(service.delayQueue);
if (!queuedTasks.isEmpty()) {
String s =
queuedTasks
.stream()
.map(BoundedTaskExecutor::info)
.collect(Collectors.toList())
.toString();
fail("Queued tasks left: " + s + ";\n" + queuedTasks);
}
service.shutdownAppScheduledExecutorService();
assertTrue(service.awaitTermination(20, TimeUnit.SECONDS));
for (Future<?> future : futures) {
assertTrue(future.isDone());
}
assertEquals(log.toString(), N, log.size());
}
public void testDelayedTasksReusePooledThreadIfExecuteAtDifferentTimes()
throws InterruptedException, ExecutionException {
final AppScheduledExecutorService service = new AppScheduledExecutorService(getName());
final List<LogInfo> log = Collections.synchronizedList(new ArrayList<>());
// pre-start one thread
Future<?> future = service.submit(EmptyRunnable.getInstance());
future.get();
service.setBackendPoolCorePoolSize(1);
assertEquals(1, service.getBackendPoolExecutorSize());
int delay = 500;
ScheduledFuture<?> f1 =
service.schedule((Runnable) () -> log.add(new LogInfo(1)), delay, TimeUnit.MILLISECONDS);
ScheduledFuture<?> f2 =
service.schedule(
(Runnable) () -> log.add(new LogInfo(2)), delay + 100, TimeUnit.MILLISECONDS);
ScheduledFuture<?> f3 =
service.schedule(
(Runnable) () -> log.add(new LogInfo(3)), delay + 200, TimeUnit.MILLISECONDS);
assertEquals(1, service.getBackendPoolExecutorSize());
assertFalse(f1.isDone());
assertFalse(f2.isDone());
assertFalse(f3.isDone());
TimeoutUtil.sleep(delay + 200 + 300);
assertTrue(f1.isDone());
assertTrue(f2.isDone());
assertTrue(f3.isDone());
assertEquals(1, service.getBackendPoolExecutorSize());
assertEquals(3, log.size());
Set<Thread> usedThreads =
new HashSet<>(
Arrays.asList(
log.get(0).currentThread, log.get(1).currentThread, log.get(2).currentThread));
if (usedThreads.size() != 1) {
System.err.println(ThreadDumper.dumpThreadsToString());
}
assertEquals(usedThreads.toString(), 1, usedThreads.size()); // must be executed in same thread
service.shutdownAppScheduledExecutorService();
assertTrue(service.awaitTermination(10, TimeUnit.SECONDS));
}
@Override
@TestOnly
public void shutdown() throws InterruptedException {
final Application app = ApplicationManager.getApplication();
assert app != null && app.isUnitTestMode() : app;
final MyProcessHandler processHandler = myProcessHandler;
if (processHandler != null) {
myIsShuttingDown = true;
shutdownProcess();
long t = System.currentTimeMillis();
while (!processHandler.isProcessTerminated()) {
if ((System.currentTimeMillis() - t) > 5000) {
throw new InterruptedException("Timed out waiting watcher process to terminate");
}
TimeoutUtil.sleep(100);
}
}
}
public void testWatchRootRecreation() throws Exception {
File rootDir = createTestDir("root");
File file1 = createTestFile(rootDir, "file1.txt", "abc");
File file2 = createTestFile(rootDir, "file2.txt", "123");
refresh(rootDir);
LocalFileSystem.WatchRequest request = watch(rootDir);
try {
myAccept = true;
assertTrue(FileUtil.delete(rootDir));
assertTrue(rootDir.mkdir());
if (SystemInfo.isLinux) TimeoutUtil.sleep(1100); // implementation specific
assertTrue(file1.createNewFile());
assertTrue(file2.createNewFile());
assertEvent(VFileContentChangeEvent.class, file1.getPath(), file2.getPath());
} finally {
unwatch(request);
delete(rootDir);
}
}
public void testDirectoryRecreation() throws Exception {
File rootDir = createTestDir("root");
File topDir = createTestDir(rootDir, "top");
File file1 = createTestFile(topDir, "file1.txt", "abc");
File file2 = createTestFile(topDir, "file2.txt", "123");
refresh(topDir);
LocalFileSystem.WatchRequest request = watch(rootDir);
try {
myAccept = true;
assertTrue(FileUtil.delete(topDir));
assertTrue(topDir.mkdir());
TimeoutUtil.sleep(100);
assertTrue(file1.createNewFile());
assertTrue(file2.createNewFile());
assertEvent(VFileContentChangeEvent.class, file1.getPath(), file2.getPath());
} finally {
unwatch(request);
delete(topDir);
}
}
@Override
@Nullable
public Project newProject(
final String projectName,
@NotNull String filePath,
boolean useDefaultProjectSettings,
boolean isDummy) {
filePath = toCanonicalName(filePath);
//noinspection ConstantConditions
if (LOG_PROJECT_LEAKAGE_IN_TESTS && ApplicationManager.getApplication().isUnitTestMode()) {
for (int i = 0; i < 42; i++) {
if (myProjects.size() < MAX_LEAKY_PROJECTS) break;
System.gc();
TimeoutUtil.sleep(100);
System.gc();
}
if (myProjects.size() >= MAX_LEAKY_PROJECTS) {
List<Project> copy = new ArrayList<Project>(myProjects.keySet());
myProjects.clear();
throw new TooManyProjectLeakedException(copy);
}
}
ProjectImpl project =
createProject(
projectName, filePath, false, ApplicationManager.getApplication().isUnitTestMode());
try {
initProject(project, useDefaultProjectSettings ? (ProjectImpl) getDefaultProject() : null);
if (LOG_PROJECT_LEAKAGE_IN_TESTS) {
myProjects.put(project, null);
}
return project;
} catch (final Exception e) {
LOG.info(e);
Messages.showErrorDialog(message(e), ProjectBundle.message("project.load.default.error"));
}
return null;
}
protected void doRun() {
try {
while (true) {
boolean read = readAvailableBlocking();
if (!read) {
break;
} else {
if (isStopped) {
break;
}
TimeoutUtil.sleep(mySleepingPolicy.getTimeToSleep(true));
}
}
} catch (Exception e) {
fireCommunicationError();
} finally {
close();
fireExitEvent();
}
}
private static void doAsyncRefreshTest(File temp) throws Exception {
final int N = 1000;
final byte[] data = "xxx".getBytes("UTF-8");
LocalFileSystem fs = LocalFileSystem.getInstance();
VirtualFile vTemp = fs.findFileByIoFile(temp);
assertNotNull(vTemp);
VirtualFile[] children = new VirtualFile[N];
long[] timestamp = new long[N];
for (int i = 0; i < N; i++) {
File file = new File(temp, i + ".txt");
FileUtil.writeToFile(file, data);
VirtualFile child = fs.refreshAndFindFileByIoFile(file);
assertNotNull(child);
children[i] = child;
timestamp[i] = file.lastModified();
}
vTemp.refresh(false, true);
for (int i = 0; i < N; i++) {
File file = new File(temp, i + ".txt");
assertEquals(timestamp[i], file.lastModified());
VirtualFile child = fs.findFileByIoFile(file);
assertNotNull(child);
IoTestUtil.assertTimestampsEqual(timestamp[i], child.getTimeStamp());
}
for (int i = 0; i < N; i++) {
File file = new File(temp, i + ".txt");
FileUtil.writeToFile(file, data);
assertTrue(file.setLastModified(timestamp[i] - 2000));
long modified = file.lastModified();
assertTrue("File:" + file.getPath() + "; time:" + modified, timestamp[i] != modified);
timestamp[i] = modified;
IoTestUtil.assertTimestampsNotEqual(children[i].getTimeStamp(), modified);
}
final CountDownLatch latch = new CountDownLatch(N);
for (final VirtualFile child : children) {
child.refresh(
true,
true,
new Runnable() {
@Override
public void run() {
latch.countDown();
}
});
TimeoutUtil.sleep(10);
}
while (latch.getCount() > 0) {
latch.await(100, TimeUnit.MILLISECONDS);
UIUtil.pump();
}
for (int i = 0; i < N; i++) {
VirtualFile child = children[i];
IoTestUtil.assertTimestampsEqual(timestamp[i], child.getTimeStamp());
}
}
private static void waitUntilIndexReady(AtomicReference<RebuildStatus> rebuildStatus) {
while (rebuildStatus.get() != OK) {
ProgressManager.checkCanceled();
TimeoutUtil.sleep(50);
}
}
public void testDelayedWorks() throws InterruptedException {
final AppScheduledExecutorService service = new AppScheduledExecutorService(getName());
final List<LogInfo> log = Collections.synchronizedList(new ArrayList<>());
assertFalse(service.isShutdown());
assertFalse(service.isTerminated());
service.invokeAll(
Collections.nCopies(
service.getBackendPoolCorePoolSize() + 1,
Executors.callable(EmptyRunnable.getInstance()))); // pre-start all threads
int delay = 1000;
long start = System.currentTimeMillis();
ScheduledFuture<?> f1 =
service.schedule(
() -> {
log.add(new LogInfo(1));
TimeoutUtil.sleep(10);
},
delay,
TimeUnit.MILLISECONDS);
assertFalse(service.isShutdown());
assertFalse(service.isTerminated());
ScheduledFuture<?> f2 =
service.schedule(
() -> {
log.add(new LogInfo(2));
TimeoutUtil.sleep(10);
},
delay,
TimeUnit.MILLISECONDS);
assertFalse(service.isShutdown());
assertFalse(service.isTerminated());
ScheduledFuture<?> f3 =
service.schedule(
() -> {
log.add(new LogInfo(3));
TimeoutUtil.sleep(10);
},
delay,
TimeUnit.MILLISECONDS);
assertFalse(service.isShutdown());
assertFalse(service.isTerminated());
Future<?> f4 = service.submit((Runnable) () -> log.add(new LogInfo(4)));
assertFalse(service.isShutdown());
assertFalse(service.isTerminated());
assertFalse(f1.isDone());
assertFalse(f2.isDone());
assertFalse(f3.isDone());
TimeoutUtil.sleep(delay / 2);
long elapsed = System.currentTimeMillis() - start; // can be > delay/2 on overloaded agent
assertEquals(String.valueOf(f1.isDone()), elapsed > delay, f1.isDone());
assertEquals(String.valueOf(f2.isDone()), elapsed > delay, f2.isDone());
assertEquals(String.valueOf(f3.isDone()), elapsed > delay, f3.isDone());
assertTrue(f4.isDone());
TimeoutUtil.sleep(delay / 2 + 500);
assertTrue(f1.isDone());
assertTrue(f2.isDone());
assertTrue(f3.isDone());
assertTrue(f4.isDone());
assertEquals(4, log.size());
assertEquals(4, log.get(0).runnable);
List<Thread> threads =
Arrays.asList(log.get(1).currentThread, log.get(2).currentThread, log.get(3).currentThread);
assertEquals(
threads.toString(), 3, new HashSet<>(threads).size()); // must be executed in parallel
service.shutdownAppScheduledExecutorService();
assertTrue(service.awaitTermination(10, TimeUnit.SECONDS));
}
