"fullMetaSearch": false,
          "hide": false,
          "includeNullMetadata": true,
          "instant": false,
          "legendFormat": "Pool {{pool}} / Set {{set}} - Read Quorum",
          "range": true,
          "refId": "B",
          "useBackend": false
        },
        {
          "datasource": {
            "type": "prometheus",

    """.trimIndent().decodeCertificatePem()

  private val client: OkHttpClient

  init {
    // This implementation just embeds the PEM files in Java strings; most applications will
    // instead read this from a resource file that gets bundled with the application.
    val certificates =
      HandshakeCertificates
        .Builder()
        .addTrustedCertificate(letsEncryptCertificateAuthority)

 * to the methods of the delegate. For example, overriding {@link #add} alone <b>will not</b> change
 * the behaviour of {@link #offer} which can lead to unexpected behaviour. In this case, you should
 * override {@code offer} as well, either providing your own implementation, or delegating to the
 * provided {@code standardOffer} method.
 *

        @ParameterizedTest
        @MethodSource("flagsProvider")
        void verifiesCreateDisposition(int flags, int expected) {
            SmbComNTCreateAndX req = createRequest(flags, 0);
            // Use reflection to read the private field createDisposition
            int actual = (int) getPrivateField(req, "createDisposition");
            assertEquals(expected, actual, "createDisposition should match");
        }
    }

    @Test

 * properties are be specified. <b>With later containers the
 * {@code NtlmHttpFilter} should be used</b>. For custom NTLM HTTP Authentication schemes the {@code NtlmSsp} may be used.
 *
 * <p>
 * Read <a href="../../../ntlmhttpauth.html">jCIFS NTLM HTTP Authentication and the Network Explorer Servlet</a> related information.
 */

public abstract class NtlmServlet extends HttpServlet {

    /**

        for (int i = 0; i < nameBytes.length; i++) {
            assertEquals(nameBytes[i], dst[12 + i]);
        }
        assertEquals((byte) 0x00, dst[12 + nameBytes.length]);
    }

    /**
     * read*WireFormat methods in request return 0 (not implemented for requests).
     */
    @Test
    void testReadWireFormatStubsReturnZero() {
        // Given

            throws IOException;

    /**
     * Calculates checksums for specified stream. Upon this method returns, the stream will be depleted (fully read)
     * but not closed.
     *
     * @param stream      The stream for which to calculate checksums, must not be {@code null}.
     * @param algorithms  The checksum algorithms to use, must not be {@code null}.

		n := 1
		var base, ext string
		base = *privKeyPath
		if idx := strings.LastIndexByte(base, '.'); idx != -1 {
			ext = base[idx:]
			base = base[:idx]
		}
		for {
			// Automatically read "file.ext", "file-2.ext", "file-3.ext"...
			fn := base + ext
			if n > 1 {
				fn = fmt.Sprintf("%s-%d%s", base, n, ext)
			}

			if b, err := os.ReadFile(fn); err == nil {
				privateKeys = append(privateKeys, b)

		Stmts:    stmt_store.New(maxSize, ttl), // Initializes a new statement store with the specified maximum size and TTL.
		Mux:      &sync.RWMutex{},              // Sets up a read-write mutex for synchronizing access to the statement store.
	}
}

// GetDBConn returns the underlying *sql.DB connection
func (db *PreparedStmtDB) GetDBConn() (*sql.DB, error) {

	resp := lockRPCRLock.NewResponse()
	success, err := l.ll.RLock(ctx, *args)
	if err == nil && !success {
		err = errLockConflict
	}
	return l.makeResp(resp, err)
}

// RUnlockHandler - releases the acquired read lock.
func (l *lockRESTServer) RUnlockHandler(args *dsync.LockArgs) (*dsync.LockResp, *grid.RemoteErr) {
	resp := lockRPCRUnlock.NewResponse()