@Test
    public void test_unclear() {
        final IntentDetectionResult result = IntentDetectionResult.unclear("unclear intent");

        assertEquals(ChatIntent.UNCLEAR, result.getIntent());
        assertNull(result.getQuery());
        assertNull(result.getDocumentUrl());
        assertEquals("unclear intent", result.getReasoning());
    }

    @Test
    public void test_unclear_withNullReasoning() {

    }

    /**
     * Creates an unclear intent result when intent cannot be determined.
     *
     * @param reasoning the detection reasoning
     * @return the unclear intent result
     */
    public static IntentDetectionResult unclear(final String reasoning) {
        return new IntentDetectionResult(ChatIntent.UNCLEAR, null, null, reasoning);
    }

    /**

    table.put("cat", 1, 'b');
    table.clear();
    populate(table, data);
    return table;
  }

  @Override
  protected TreeBasedTable<String, Integer, Character> create(@Nullable Object... data) {
    TreeBasedTable<String, Integer, Character> table = TreeBasedTable.create();
    table.put("foo", 4, 'a');
    table.put("cat", 1, 'b');
    table.clear();
    populate(table, data);
    return table;
  }

	}

	// Clear
	DB.Model(&blog2).Association("LocaleTags").Clear()
	if DB.Model(&blog).Association("LocaleTags").Count() != 3 {
		t.Fatalf("ZH Blog's tags should not be cleared when clear EN Blog's tags")
	}

	if DB.Model(&blog2).Association("LocaleTags").Count() != 0 {
		t.Fatalf("EN Blog's tags should be cleared when clear EN Blog's tags")
	}

    return (row == null) ? null : safeGet(row, columnKey);
  }

  @Override
  public boolean isEmpty() {
    return size() == 0;
  }

  @Override
  public void clear() {
    Iterators.clear(cellSet().iterator());
  }

  @CanIgnoreReturnValue
  @Override
  public @Nullable V remove(@Nullable Object rowKey, @Nullable Object columnKey) {
    Map<C, V> row = safeGet(rowMap(), rowKey);

    assert "/async_raise" in errors
    errors.clear()


def test_async_raise_server_error():
    client = TestClient(app, raise_server_exceptions=False)
    response = client.get("/async_raise")
    assert response.status_code == 500, response.text
    assert state["/async_raise"] == "asyncgen raise finalized"
    assert "/async_raise" in errors
    errors.clear()


def test_context_b():

repeats of these filename(s) with different casing:
EOF
    find . | tr '[A-Z]' '[a-z]' | sort | uniq -d | tee $BATS_FILE_TMPDIR/repeats
    [[ ! -s $BATS_FILE_TMPDIR/repeats ]]
}

# It's unclear why, but running this on //tensorflow/... is faster than running
# only on affected targets, usually. There are targets in //tensorflow/lite that
# don't pass --nobuild, so they're on their own.
#

        userPager.setAllPageCount(10);
        userPager.setExistPrePage(true);
        userPager.setExistNextPage(true);

        userPager.clear();

        assertNull(userPager.id);
        // Note: name is not cleared by clear() method
        assertNull(userPager.roles);
        assertNull(userPager.groups);
        assertNull(userPager.versionNo);
        assertEquals(0, userPager.getAllRecordCount());

    totalSize -= collection.size();
    collection.clear();

    return unmodifiableCollectionSubclass(output);
  }

  <E extends @Nullable Object> Collection<E> unmodifiableCollectionSubclass(
      Collection<E> collection) {
    return Collections.unmodifiableCollection(collection);
  }

  @Override
  public void clear() {
    // Clear each collection, to make previously returned collections empty.

    return delegate.ceilingEntry(checkValid(key));
  }

  @Override
  public @Nullable K ceilingKey(K key) {
    return delegate.ceilingKey(checkValid(key));
  }

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

  @Override
  public Comparator<? super K> comparator() {
    Comparator<? super K> comparator = delegate.comparator();
    if (comparator != null) {
      return comparator;
    }