diff options
author | Automerger Merge Worker <android-build-automerger-merge-worker@system.gserviceaccount.com> | 2020-03-05 04:33:08 +0000 |
---|---|---|
committer | Automerger Merge Worker <android-build-automerger-merge-worker@system.gserviceaccount.com> | 2020-03-05 04:33:08 +0000 |
commit | 7cb579a056a38c222e4602602ec68273b2dc46a4 (patch) | |
tree | f8cbc802a806455c5fdfeab7f696c63641b9f9f5 /jimfs/src/test/java/com/google/common/jimfs/AbstractWatchServiceTest.java | |
parent | 68591711a9034281d5fe11fc7a30e535bbce125c (diff) | |
parent | c5f71e95df2f3189f2b68140ebac0c76a238190f (diff) | |
download | jimfs-7cb579a056a38c222e4602602ec68273b2dc46a4.tar.gz |
Initial merge with upstream am: cef92d673c am: c5f71e95df
Change-Id: I8cb86c1ef1be53141ae974516ff4dcde25e8165a
Diffstat (limited to 'jimfs/src/test/java/com/google/common/jimfs/AbstractWatchServiceTest.java')
-rw-r--r-- | jimfs/src/test/java/com/google/common/jimfs/AbstractWatchServiceTest.java | 253 |
1 files changed, 253 insertions, 0 deletions
diff --git a/jimfs/src/test/java/com/google/common/jimfs/AbstractWatchServiceTest.java b/jimfs/src/test/java/com/google/common/jimfs/AbstractWatchServiceTest.java new file mode 100644 index 0000000..61ddeb8 --- /dev/null +++ b/jimfs/src/test/java/com/google/common/jimfs/AbstractWatchServiceTest.java @@ -0,0 +1,253 @@ +/* + * Copyright 2013 Google Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.google.common.jimfs; + +import static com.google.common.jimfs.AbstractWatchService.Key.State.READY; +import static com.google.common.jimfs.AbstractWatchService.Key.State.SIGNALLED; +import static com.google.common.truth.Truth.assertThat; +import static java.nio.file.StandardWatchEventKinds.ENTRY_CREATE; +import static java.nio.file.StandardWatchEventKinds.ENTRY_DELETE; +import static java.nio.file.StandardWatchEventKinds.ENTRY_MODIFY; +import static java.nio.file.StandardWatchEventKinds.OVERFLOW; +import static java.util.concurrent.TimeUnit.SECONDS; +import static org.junit.Assert.fail; + +import com.google.common.collect.ImmutableList; +import com.google.common.collect.ImmutableSet; +import java.io.IOException; +import java.nio.file.ClosedWatchServiceException; +import java.nio.file.Path; +import java.nio.file.WatchEvent; +import java.nio.file.WatchKey; +import java.nio.file.WatchService; +import java.nio.file.Watchable; +import java.util.Arrays; +import java.util.List; +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.junit.runners.JUnit4; + +/** + * Tests for {@link AbstractWatchService}. + * + * @author Colin Decker + */ +@RunWith(JUnit4.class) +public class AbstractWatchServiceTest { + + private AbstractWatchService watcher; + + @Before + public void setUp() throws IOException { + watcher = new AbstractWatchService() {}; + } + + @Test + public void testNewWatcher() throws IOException { + assertThat(watcher.isOpen()).isTrue(); + assertThat(watcher.poll()).isNull(); + assertThat(watcher.queuedKeys()).isEmpty(); + watcher.close(); + assertThat(watcher.isOpen()).isFalse(); + } + + @Test + public void testRegister() throws IOException { + Watchable watchable = new StubWatchable(); + AbstractWatchService.Key key = watcher.register(watchable, ImmutableSet.of(ENTRY_CREATE)); + assertThat(key.isValid()).isTrue(); + assertThat(key.pollEvents()).isEmpty(); + assertThat(key.subscribesTo(ENTRY_CREATE)).isTrue(); + assertThat(key.subscribesTo(ENTRY_DELETE)).isFalse(); + assertThat(key.watchable()).isEqualTo(watchable); + assertThat(key.state()).isEqualTo(READY); + } + + @Test + public void testPostEvent() throws IOException { + AbstractWatchService.Key key = + watcher.register(new StubWatchable(), ImmutableSet.of(ENTRY_CREATE)); + + AbstractWatchService.Event<Path> event = + new AbstractWatchService.Event<>(ENTRY_CREATE, 1, null); + key.post(event); + key.signal(); + + assertThat(watcher.queuedKeys()).containsExactly(key); + + WatchKey retrievedKey = watcher.poll(); + assertThat(retrievedKey).isEqualTo(key); + + List<WatchEvent<?>> events = retrievedKey.pollEvents(); + assertThat(events).hasSize(1); + assertThat(events.get(0)).isEqualTo(event); + + // polling should have removed all events + assertThat(retrievedKey.pollEvents()).isEmpty(); + } + + @Test + public void testKeyStates() throws IOException { + AbstractWatchService.Key key = + watcher.register(new StubWatchable(), ImmutableSet.of(ENTRY_CREATE)); + + AbstractWatchService.Event<Path> event = + new AbstractWatchService.Event<>(ENTRY_CREATE, 1, null); + assertThat(key.state()).isEqualTo(READY); + key.post(event); + key.signal(); + assertThat(key.state()).isEqualTo(SIGNALLED); + + AbstractWatchService.Event<Path> event2 = + new AbstractWatchService.Event<>(ENTRY_CREATE, 1, null); + key.post(event2); + assertThat(key.state()).isEqualTo(SIGNALLED); + + // key was not queued twice + assertThat(watcher.queuedKeys()).containsExactly(key); + assertThat(watcher.poll().pollEvents()).containsExactly(event, event2); + + assertThat(watcher.poll()).isNull(); + + key.post(event); + + // still not added to queue; already signalled + assertThat(watcher.poll()).isNull(); + assertThat(key.pollEvents()).containsExactly(event); + + key.reset(); + assertThat(key.state()).isEqualTo(READY); + + key.post(event2); + key.signal(); + + // now that it's reset it can be requeued + assertThat(watcher.poll()).isEqualTo(key); + } + + @Test + public void testKeyRequeuedOnResetIfEventsArePending() throws IOException { + AbstractWatchService.Key key = + watcher.register(new StubWatchable(), ImmutableSet.of(ENTRY_CREATE)); + key.post(new AbstractWatchService.Event<>(ENTRY_CREATE, 1, null)); + key.signal(); + + key = (AbstractWatchService.Key) watcher.poll(); + assertThat(watcher.queuedKeys()).isEmpty(); + + assertThat(key.pollEvents()).hasSize(1); + + key.post(new AbstractWatchService.Event<>(ENTRY_CREATE, 1, null)); + assertThat(watcher.queuedKeys()).isEmpty(); + + key.reset(); + assertThat(key.state()).isEqualTo(SIGNALLED); + assertThat(watcher.queuedKeys()).hasSize(1); + } + + @Test + public void testOverflow() throws IOException { + AbstractWatchService.Key key = + watcher.register(new StubWatchable(), ImmutableSet.of(ENTRY_CREATE)); + for (int i = 0; i < AbstractWatchService.Key.MAX_QUEUE_SIZE + 10; i++) { + key.post(new AbstractWatchService.Event<>(ENTRY_CREATE, 1, null)); + } + key.signal(); + + List<WatchEvent<?>> events = key.pollEvents(); + + assertThat(events).hasSize(AbstractWatchService.Key.MAX_QUEUE_SIZE + 1); + for (int i = 0; i < AbstractWatchService.Key.MAX_QUEUE_SIZE; i++) { + assertThat(events.get(i).kind()).isEqualTo(ENTRY_CREATE); + } + + WatchEvent<?> lastEvent = events.get(AbstractWatchService.Key.MAX_QUEUE_SIZE); + assertThat(lastEvent.kind()).isEqualTo(OVERFLOW); + assertThat(lastEvent.count()).isEqualTo(10); + } + + @Test + public void testResetAfterCancelReturnsFalse() throws IOException { + AbstractWatchService.Key key = + watcher.register(new StubWatchable(), ImmutableSet.of(ENTRY_CREATE)); + key.signal(); + key.cancel(); + assertThat(key.reset()).isFalse(); + } + + @Test + public void testClosedWatcher() throws IOException, InterruptedException { + AbstractWatchService.Key key1 = + watcher.register(new StubWatchable(), ImmutableSet.of(ENTRY_CREATE)); + AbstractWatchService.Key key2 = + watcher.register(new StubWatchable(), ImmutableSet.of(ENTRY_MODIFY)); + + assertThat(key1.isValid()).isTrue(); + assertThat(key2.isValid()).isTrue(); + + watcher.close(); + + assertThat(key1.isValid()).isFalse(); + assertThat(key2.isValid()).isFalse(); + assertThat(key1.reset()).isFalse(); + assertThat(key2.reset()).isFalse(); + + try { + watcher.poll(); + fail(); + } catch (ClosedWatchServiceException expected) { + } + + try { + watcher.poll(10, SECONDS); + fail(); + } catch (ClosedWatchServiceException expected) { + } + + try { + watcher.take(); + fail(); + } catch (ClosedWatchServiceException expected) { + } + + try { + watcher.register(new StubWatchable(), ImmutableList.<WatchEvent.Kind<?>>of()); + fail(); + } catch (ClosedWatchServiceException expected) { + } + } + + // TODO(cgdecker): Test concurrent use of Watcher + + /** A fake {@link Watchable} for testing. */ + private static final class StubWatchable implements Watchable { + + @Override + public WatchKey register( + WatchService watcher, WatchEvent.Kind<?>[] events, WatchEvent.Modifier... modifiers) + throws IOException { + return register(watcher, events); + } + + @Override + public WatchKey register(WatchService watcher, WatchEvent.Kind<?>... events) + throws IOException { + return ((AbstractWatchService) watcher).register(this, Arrays.asList(events)); + } + } +} |