* finalizable references could be enqueued subsequently (at which point the class loader
       * would be resurrected by virtue of us having a strong reference to it), we should pretty
       * much just shut down and make sure we don't keep it alive any longer than necessary.
       */
      return null;
    }
    try {
      return finalizableReferenceClass.getMethod("finalizeReferent");
    } catch (NoSuchMethodException e) {

        // When
        // Then
    }
}
```

**Coverage Goal**: >80% line coverage

### Contributing

1. Fork repo
2. Create feature branch (`feature/amazing-feature`)
3. Make focused commits
4. Add tests
5. Format code (`mvn formatter:format && mvn license:format`)
6. Run tests (`mvn test`)
7. Open Pull Request

---

## Common Development Tasks

            outputFile = createTempFile("cmdextout_" + filePrefix + "_", "." + outExt, tempDir);

            // store to a file
            CopyUtil.copy(in, inputFile);

            LocalConverter.make(officeManager).convert(inputFile).to(outputFile).execute();

            final ExtractData extractData = new ExtractData(getOutputContent(outputFile, outExt));
            if (StringUtil.isNotBlank(resourceName)) {

## Changes since v1.2.2

### Action Required

* Make watch cache treat resourceVersion consistent with uncached watch ([#24008](https://github.com/kubernetes/kubernetes/pull/24008), [@liggitt](https://github.com/liggitt))

### Other notable changes

      return array.length;
    }
  }

  /**
   * Implementation of Striped where up to 2^k stripes can be represented, using an
   * AtomicReferenceArray of size 2^k. To map a user key into a stripe, we take a k-bit slice of the
   * user key's (smeared) hashCode(). The stripes are lazily initialized and are weakly referenced.
   */
  @VisibleForTesting
  static final class SmallLazyStriped<L> extends PowerOfTwoStriped<L> {

 *     logger.info("Done with {0}", name);
 *   }
 * }, executor);
 * }
 *
 * <h3>How to get an instance</h3>
 *
 * <p>We encourage you to return {@code ListenableFuture} from your methods so that your users can
 * take advantage of the {@linkplain Futures utilities built atop the class}. The way that you will
 * create {@code ListenableFuture} instances depends on how you currently create {@code Future}
 * instances:
 *
 * <ul>

 *     logger.info("Done with {0}", name);
 *   }
 * }, executor);
 * }
 *
 * <h3>How to get an instance</h3>
 *
 * <p>We encourage you to return {@code ListenableFuture} from your methods so that your users can
 * take advantage of the {@linkplain Futures utilities built atop the class}. The way that you will
 * create {@code ListenableFuture} instances depends on how you currently create {@code Future}
 * instances:
 *
 * <ul>

    $ mvn package     # Build the package

#### 2. Start Fess Server

    $ unzip target/releases/fess-*.zip
    $ ./fess-*/bin/fess &

Wait for Fess to be ready (this may take up to 60 seconds):

    $ curl -s "http://localhost:8080/api/v1/health"

You should see a JSON response when Fess is ready.

#### 3. Clone Test Data

Required for SearchApiTests:

            val delayNanos =
              logger.logElapsed(task, task.queue!!) {
                task.runOnce()
              }

            // A task ran successfully. Update the execution state and take the next task.
            task = withLock {
              afterRun(task, delayNanos, true)
              awaitTaskToRun()
            } ?: return
          }
        } catch (thrown: Throwable) {

   * itself. In all other cases, the inverse is a transformation such that applying both the
   * original transformation and its inverse to a value gives you the original value give-or-take
   * numerical errors. Calling this method multiple times on the same instance will always return
   * the same instance. Calling this method on the result of calling this method on an instance will