* either express or implied. See the License for the specific language
 * governing permissions and limitations under the License.
 */
package org.codelibs.fess.opensearch.log.cbean.ca;

import org.codelibs.fess.opensearch.log.cbean.ca.bs.BsSearchLogCA;

/**
 * @author ESFlute (using FreeGen)
 */
public class SearchLogCA extends BsSearchLogCA {

 * either express or implied. See the License for the specific language
 * governing permissions and limitations under the License.
 */
package org.codelibs.fess.opensearch.user.cbean.cq;

import org.codelibs.fess.opensearch.user.cbean.cq.bs.BsGroupCQ;

/**
 * @author ESFlute (using FreeGen)
 */
public class GroupCQ extends BsGroupCQ {

    @Test
    public void test_DocList() {
        Map<String, Object> value = new LinkedHashMap<>();
        DocMap docMap = new DocMap(value);
        assertTrue(docMap.isEmpty());
        value.clear();

        List<String> keys = Arrays.asList("test_2", "test_0", "lang", "test_1");
        value.put(keys.get(0), true);
        value.put(keys.get(1), 1000);
        value.put(keys.get(2), "ja");

      if (record != null) {
        list.add(record);
      }
    }
  }

  @Override
  public void flush() {}

  @Override
  public void close() {}

  public void clear() {
    synchronized (lock) {
      list.clear();
    }
  }

  /** Returns a snapshot of the logged records. */
  /*
   * TODO(cpovirk): consider higher-level APIs here (say, assertNoRecordsLogged(),

    return Iterables.removeIf(
        multimap.unfiltered().entries(),
        and(multimap.entryPredicate(), valuePredicateOnEntries(not(in(c)))));
  }

  @Override
  public void clear() {
    multimap.clear();
  }

import org.codelibs.fess.unit.UnitFessTestCase;

public class GroupPagerTest extends UnitFessTestCase {

    public void test_GroupPager() {
        GroupPager groupPager = new GroupPager();

        groupPager.clear();
        assertEquals(0, groupPager.getAllRecordCount());
        assertEquals(0, groupPager.getAllPageCount());
        assertEquals(false, groupPager.isExistPrePage());

import org.codelibs.fess.unit.UnitFessTestCase;

public class PathMapPagerTest extends UnitFessTestCase {

    public void test_PathMapPager() {
        PathMapPager pathMapPager = new PathMapPager();

        pathMapPager.clear();
        assertEquals(0, pathMapPager.getAllRecordCount());
        assertEquals(0, pathMapPager.getAllPageCount());
        assertEquals(false, pathMapPager.isExistPrePage());

  operator fun set(
    hostname: String,
    addresses: List<InetAddress>,
  ): FakeDns {
    hostAddresses[hostname] = addresses
    return this
  }

  /** Clears the results for `hostname`.  */
  fun clear(hostname: String): FakeDns {
    hostAddresses.remove(hostname)
    return this
  }

  @Throws(UnknownHostException::class)
  fun lookup(
    hostname: String,
    index: Int,

    table.put("b", "b", "x");
    table.put("b", "c", "y");
    table.put("b", "x", "n");
    table.put("a", "a", "d");
    table.row("b").subMap("c", "x").clear();
    assertEquals(table.row("b"), ImmutableMap.of("b", "x", "x", "n"));
    table.row("b").subMap("b", "y").clear();
    assertEquals(table.row("b"), ImmutableMap.of());
    assertFalse(table.backingMap.containsKey("b"));
  }

    @Override
    public @Nullable V remove(Object object) {
      assertTrue(Thread.holdsLock(mutex));
      return super.remove(object);
    }

    @Override
    public void clear() {
      assertTrue(Thread.holdsLock(mutex));
      super.clear();
    }

    @Override
    public boolean containsKey(Object key) {
      assertTrue(Thread.holdsLock(mutex));
      return super.containsKey(key);
    }

    @Override