//                                                                       =============
    @Override
    public String asTableDbName() {
        return "label_type";
    }

    @Override
    public String xgetAliasName() {
        return "label_type";
    }

    // ===================================================================================

        List<FileNotifyInformation> result = sut.watch();

        assertNull(result, "Cancelled watch should return null");
        verify(tree, times(1)).close();
    }

    // Error code 0x10C should clear the notify list and return it
    @Test
    @DisplayName("watch() clears notify list on error 0x10C and returns it")
    void watch_clearsList_onError10C() throws Exception {

 protected:
  explicit TracingTensorHandle(AbstractTensorHandleKind kind)
      : AbstractTensorHandle(kind) {}

 public:
  // For LLVM style RTTI.
  static bool classof(const AbstractTensorHandle* ptr) {
    return ptr->getKind() == kGraph || ptr->getKind() == kMlir;
  }
};

// An abstract operation describes an operation by its type, name, and
// attributes. It can be "executed" by the context with some input tensors.

    // we can get away with i++ because the whole point of this method is to return false if we find
    // a code point that doesn't fit in a char.
    for (int i = 0; i < string.length(); i++) {
      if (string.codePointAt(i) > 0xffff) {
        return false;
      }
    }
    return true;
  }

  @SuppressWarnings("deprecation")
  public void testSimpleStringUtf8() {

     *
     * @param value the value to search for in the buffered lines
     * @return true if a matching line is found, false otherwise
     */
    public boolean contains(final String value) {
        for (final String line : list) {
            if (line.trim().equals(value)) {
                return true;
            }
        }
        return false;
    }

            )
        return resultIncludingDuplicates.distinctBy { it.name }
    }

    private fun determineSubProjectClassTimes(
        testCoverage: TestCoverage,
        buildProjectClassTimes: BuildProjectToSubprojectTestClassTimes,
    ): Map<String, List<TestClassTime>>? {
        val testCoverageId = testCoverage.asId(MASTER_CHECK_CONFIGURATION)

    minIntermediates: Int,
  ): Boolean {
    if (toVerify.issuerDN != signingCert.subjectDN) {
      return false
    }
    if (signingCert.basicConstraints < minIntermediates) {
      return false // The signer can't have this many intermediates beneath it.
    }
    return try {
      toVerify.verify(signingCert.publicKey)
      true
    } catch (verifyFailed: GeneralSecurityException) {
      false

    }

    /**
     * Get the actual port the server is listening on.
     * This is useful when starting the server with port 0 to get a random available port.
     *
     * @return the actual port number
     */
    public int getPort() {
        return ((ServerConnector) server.getConnectors()[0]).getLocalPort();
    }

    protected static File createDocRoot(final int count) {
        try {

            throw new IllegalStateException(getNoRootMessage());
        }
        return rootDirectory;
    }

    @Nullable
    default Path findRoot(Path basedir) {
        Path rootDirectory = basedir;
        while (rootDirectory != null && !isRootDirectory(rootDirectory)) {
            rootDirectory = rootDirectory.getParent();
        }
        return rootDirectory;
    }

    @Nonnull
    default String getNoRootMessage() {

    @Override
    protected int getDefaultPort() {
        return SmbConstants.DEFAULT_PORT;
    }

    @Override
    public URLConnection openConnection(final URL u) throws IOException {
        if (log.isDebugEnabled()) {
            log.debug("Opening file " + u);
        }
        return new SmbFile(u, getTransportContext());
    }

    /**
     * @return
     */
    private CIFSContext getTransportContext() {