//        policeStoryOfJavaClassChase(new ActionComponentPolice(tp -> getComponent(tp)));
    //    }

    // TODO
    //    public void test_hotDeployDestroyer() throws Exception {
    //        policeStoryOfJavaClassChase(new HotDeployDestroyerPolice(tp -> getComponent(tp)));
    //    }

    public void test_nonActionExtendsAction() throws Exception {
        policeStoryOfJavaClassChase(new NonActionExtendsActionPolice());

      LongAdder unused = new LongAdder();
      supplier =
          new Supplier<LongAddable>() {
            @Override
            public LongAddable get() {
              return new LongAdder();
            }
          };
    } catch (Throwable t) { // we really want to catch *everything*
      supplier =
          new Supplier<LongAddable>() {
            @Override

        super(server, 200, 0xFFFF, new netdfs.DfsEnumStruct(), new NdrLong(0));
        info.level = level;
        info.e = new netdfs.DfsEnumArray200();
        ptype = 0;
        flags = DCERPC_FIRST_FRAG | DCERPC_LAST_FRAG;
    }

    public FileEntry[] getEntries() {
        netdfs.DfsEnumArray200 a200 = (netdfs.DfsEnumArray200)info.e;
        SmbShareInfo[] entries = new SmbShareInfo[a200.count];

        ElevateWordToLabelCQ cq = new ElevateWordToLabelCQ();
        if (queryLambda != null) {
            queryLambda.callback(cq);
        }
        FilterAggregationBuilder builder = regFilterA(name, cq.getQuery());
        if (opLambda != null) {
            opLambda.callback(builder);
        }
        if (aggsLambda != null) {
            ElevateWordToLabelCA ca = new ElevateWordToLabelCA();

              ? RegularImmutableMap.makeImmutable(entry, key, value)
              : new NonTerminalImmutableBiMapEntry<>(
                  key, value, nextInKeyBucket, nextInValueBucket);
      keyTable[keyBucket] = newEntry;
      valueTable[valueBucket] = newEntry;
      entries[i] = newEntry;
      hashCode += keyHash ^ valueHash;
    }
    return new RegularImmutableBiMap<>(keyTable, valueTable, entries, mask, hashCode);
  }

   * gets invoked from other immutable collections.
   */
  public void testDoesntCheckForNull() {
    ImmutableSet<Integer> set = ImmutableSet.of(1, 2, 3);
    ImmutableList<Integer> unused =
        new RegularImmutableAsList<Integer>(set, new @Nullable Object[] {null, null, null});
    // shouldn't throw!
  }

    this.byteSource = new TestByteSource(content.getBytes(UTF_8), options);
  }

  @Override
  public boolean wasStreamOpened() {
    return byteSource.wasStreamOpened();
  }

  @Override
  public boolean wasStreamClosed() {
    return byteSource.wasStreamClosed();
  }

  @Override
  public Reader openStream() throws IOException {
    return new InputStreamReader(byteSource.openStream(), UTF_8);

        final String modelName = fessConfig.getLtrModelName();
        if (StringUtil.isBlank(modelName)) {
            return null;
        }
        return new QueryRescorerBuilder(new StoredLtrQueryBuilder().modelName(modelName).params(params))
                .windowSize(fessConfig.getLtrWindowSize());
    }

            Files.delete(file.toPath());
        }
    }

    public InputStream getInputStream() throws IOException {
        if (file != null) {
            return new FileInputStream(file);
        }
        return new ByteArrayInputStream(data);
    }

/**
 * A byte sink for testing that has configurable behavior.
 *
 * @author Colin Decker
 */
public class TestByteSink extends ByteSink implements TestStreamSupplier {

  private final ByteArrayOutputStream bytes = new ByteArrayOutputStream();
  private final ImmutableSet<TestOption> options;

  private boolean outputStreamOpened;
  private boolean outputStreamClosed;

  public TestByteSink(TestOption... options) {