func_graph_(TF_NewGraph()),
        host_graph_(TF_NewGraph()),
        func_(nullptr) {}

  void SetUp() override {}

  ~CApiFunctionTest() override {
    TF_DeleteFunction(func_);
    TF_DeleteGraph(host_graph_);
    TF_DeleteGraph(func_graph_);
    TF_DeleteStatus(s_);
  }

  void Run(const std::vector<std::pair<TF_Operation*, TF_Tensor*>>& inputs,
           TF_Operation* output, int32_t expected_result) {

import java.util.stream.Collectors;

import org.codelibs.core.beans.util.BeanUtil;
import org.dbflute.Entity;
import org.lastaflute.web.response.render.RenderData;

public class RenderDataUtil {

    public static void register(final RenderData data, final String key, final Object value) {
        if (value == null) {
            return;
        }

        if (value instanceof Entity) {

        this.data = data;
        this.file = null;
    }

    public ContentCache(final File file) {
        this.data = null;
        this.file = file;
    }

    @Override
    public void close() throws IOException {
        if (file != null) {
            Files.delete(file.toPath());
        }
    }

    public InputStream getInputStream() throws IOException {
        if (file != null) {

        super(threshold, PREFIX, SUFFIX, tmpDir);
    }

    @Override
    public File getFile() {
        done = true;
        return super.getFile();
    }

    @Override
    public void close() throws IOException {
        try {
            super.close();
        } finally {
            if (!isInMemory() && !done) {
                final File file = super.getFile();
                if (file != null) {

import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;

import org.codelibs.fess.unit.UnitFessTestCase;

public class DocMapTest extends UnitFessTestCase {
    public void test_DocList() {
        Map<String, Object> value = new LinkedHashMap<>();
        DocMap docMap = new DocMap(value);
        assertTrue(docMap.isEmpty());
        value.clear();

@SuppressWarnings("JUnit4ClassUsedInJUnit3")
public class MapSerializationTester<K, V> extends AbstractMapTester<K, V> {
  @CollectionFeature.Require(SERIALIZABLE)
  public void testReserializeMap() {
    Map<K, V> deserialized = SerializableTester.reserialize(getMap());
    new EqualsTester().addEqualityGroup(getMap(), deserialized).testEquals();
  }

    return new Out();
  }

  private final class Out extends TestOutputStream {

    public Out() throws IOException {
      super(bytes, options);
    }

    @Override
    public void close() throws IOException {
      outputStreamClosed = true;
      super.close();
    }
  }

    /**
     * Invoked just before session is created with a mutable map that carries collected user properties so far.
     *
     * @param userProperties The mutable user properties, never {@code null}.
     */
    void contribute(Map<String, String> userProperties);

/**
 * Tests {@link AndArtifactFilter}.
 *
 */
class AndArtifactFilterTest {

    private ArtifactFilter newSubFilter() {
        return artifact -> false;
    }

    @Test
    void testEquals() {
        AndArtifactFilter filter1 = new AndArtifactFilter();

        AndArtifactFilter filter2 = new AndArtifactFilter(Arrays.asList(newSubFilter()));

        assertFalse(filter1.equals(null));

        this.lookup = new DefaultLookup(plexusContainer);
    }

    @Override
    public Lookup getLookup() {
        return lookup;
    }

    @Override
    public void close() {
        try {
            plexusContainer.dispose();
        } finally {
            Thread.currentThread().setContextClassLoader(previousClassLoader);
        }
    }