pkg syscall (windows-386), const SW_SHOWNA ideal-int
pkg syscall (windows-386), const SW_SHOWNOACTIVATE ideal-int
pkg syscall (windows-386), const SW_SHOWNORMAL ideal-int
pkg syscall (windows-386), const SYNCHRONIZE ideal-int
pkg syscall (windows-386), const S_IWRITE ideal-int
pkg syscall (windows-386), const SidTypeAlias ideal-int
pkg syscall (windows-386), const SidTypeComputer ideal-int

                            List<Map<String, Object>> results =
                                    processor.search("*", new TestSearchRequestParams(0, 10, 0), OptionalThing.empty());
                            synchronized (allResults) {
                                allResults.add(results);
                            }
                        } catch (InterruptedException e) {

            this.fp = 0L;
        } catch (final CIFSException e) {
            throw SmbException.wrap(e);
        }
    }

    /**
     * @return
     * @throws SmbException
     */
    synchronized SmbFileHandleImpl ensureOpen() throws CIFSException {
        // ensure file is open
        if (this.handle == null || !this.handle.isValid()) {
            // one extra acquire to keep this open till the stream is released

    }

    @Test
    public void test_evaluate_concurrency() {
        queryRescorer = new QueryRescorer() {
            private int callCount = 0;

            @Override
            public synchronized RescorerBuilder<?> evaluate(Map<String, Object> params) {
                callCount++;
                if (callCount % 2 == 0) {
                    return createMockRescorerBuilder();
                }

  }

  private static class TestApplication extends Application {
    private final List<Thread> hooks = new ArrayList<>();

    @Override
    synchronized void addShutdownHook(Thread hook) {
      hooks.add(hook);
    }

    synchronized void shutdown() throws InterruptedException {
      for (Thread hook : hooks) {
        hook.start();
      }
      for (Thread hook : hooks) {
        hook.join();

            this.epoch = 1;
            this.breaking = false;
        }
        
        public synchronized void updateState(int newState) {
            this.leaseState = newState;
            this.lastAccessTime = System.currentTimeMillis();
        }
        
        public synchronized void incrementEpoch() {
            this.epoch++;
        }
        
        public boolean hasReadCache() {

  }

  static class DecoupledClassLoader extends URLClassLoader {

    public DecoupledClassLoader(URL[] urls) {
      super(urls);
    }

    @Override
    protected synchronized Class<?> loadClass(String name, boolean resolve)
        throws ClassNotFoundException {
      // Force Finalizer to load from this class loader, not its parent.
      if (name.equals(Finalizer.class.getName())) {

        toArrayCalled = true;
        return super.toArray(a);
      }
    }

    // Test that toArray() is used to make a defensive copy in copyOf(), so concurrently modified
    // synchronized collections can be safely copied.
    TestArrayList<String> toCopy = new TestArrayList<>();
    ImmutableSortedMultiset<String> unused =
        ImmutableSortedMultiset.copyOf(Ordering.natural(), toCopy);

                            synchronized (project) {
                                cleanProjectLocalRepository(project);
                            }
                        }
                    }
                }
                break;
            case ProjectSucceeded:
            case ForkedProjectSucceeded:
                synchronized (project) {

            }
            destroyContainer();
        }

        System.exit(exitCode);
    }

    private static void destroyContainer() {
        TimeoutManager.getInstance().stop();
        synchronized (SingletonLaContainerFactory.class) {
            SingletonLaContainerFactory.destroy();
        }
    }

    private static int process(final Options options) {