.replace("\"size\":\\s+\\d+".toRegex(), "\"size\": 0")
                .replace("\"sha512\":\\s+\"\\w+\"".toRegex(), "\"sha512\": \"\"")
                .replace("\"sha1\":\\s+\"\\w+\"".toRegex(), "\"sha1\": \"\"")
                .replace("\"sha256\":\\s+\"\\w+\"".toRegex(), "\"sha256\": \"\"")
                .replace("\"md5\":\\s+\"\\w+\"".toRegex(), "\"md5\": \"\"")
            it.writeText(content)
        }

        }
        return Encdec.dec_uint16be(this.tmp, 0) & 0xFFFF;
    }

    @Override
    public final char readChar() throws SmbException {
        if (read(this.tmp, 0, 2) < 0) {
            throw new SmbEndOfFileException();
        }
        return (char) Encdec.dec_uint16be(this.tmp, 0);
    }

    @Override
    public final int readInt() throws SmbException {

package clause

const (
	LockingStrengthUpdate    = "UPDATE"
	LockingStrengthShare     = "SHARE"
	LockingOptionsSkipLocked = "SKIP LOCKED"
	LockingOptionsNoWait     = "NOWAIT"
)

type Locking struct {
	Strength string
	Table    Table
	Options  string
}

// Name where clause name
func (locking Locking) Name() string {
	return "FOR"
}

// Build build where clause
func (locking Locking) Build(builder Builder) {

        scanner.next();
    }

    private void parseHtmlEncodedChar(StringBuilder buffer) {
        scanner.next(2);
        scanner.mark();
        scanner.find(';');
        String value = new String(new char[]{(char) Integer.parseInt(scanner.region())});
        buffer.append(value);
        scanner.next();
    }

    private void parseJavadocTag(TokenVisitor visitor) {
        // start of tag marker

    }

    /**
     * Retrieves the share associated with this SMB resource. In
     * the case of <code>smb://</code>, <code>smb://workgroup/</code>,
     * and <code>smb://server/</code> URLs which do not specify a share,
     * <code>null</code> will be returned.
     *
     * @return The share component or <code>null</code> if there is no share
     */
    public String getShare() {

            throw new IOException("Witness async notify RPC failed", e);
        }
    }

    /**
     * Generates a registration ID from context handle and share name.
     *
     * @param contextHandle the context handle
     * @param shareName the share name
     * @return the registration ID
     */
    private String generateRegistrationId(byte[] contextHandle, String shareName) {

    BufferedReader reader = source.openBufferedStream();
    assertTrue(source.wasStreamOpened());
    assertFalse(source.wasStreamClosed());

    StringWriter writer = new StringWriter();
    char[] buf = new char[64];
    int read;
    while ((read = reader.read(buf)) != -1) {
      writer.write(buf, 0, read);
    }
    reader.close();
    writer.close();

    assertTrue(source.wasStreamClosed());

  TF_DeletePluggableDeviceLibraryHandle(lib);
#endif  // !defined(TENSORFLOW_NO_SHARED_OBJECTS)
#endif  // !defined(PLATFORM_WINDOWS)
}

void DefineFunction(const char* name, TF_Function** func,
                    const char* description = nullptr,
                    bool append_hash = false) {
  std::unique_ptr<TF_Graph, decltype(&TF_DeleteGraph)> func_graph(
      TF_NewGraph(), TF_DeleteGraph);

    public void testNewStringUnsafe() {
        assertNull(StringUtil.newStringUnsafe(null));
        char[] chars = new char[0];
        assertThat(StringUtil.newStringUnsafe(chars), is(""));
        chars = new char[] { 'a', 'b', 'c' };
        assertThat(StringUtil.newStringUnsafe(chars), is("abc"));
        chars = new char[] { 'a', 'b', 'c', ' ' };
        assertThat(StringUtil.newStringUnsafe(chars), is("abc "));
    }

        connectionState = 0;
    }

    synchronized SmbTree getSmbTree(String share, final String service) {
        SmbTree t;

        if (share == null) {
            share = "IPC$";
        }
        for (final Enumeration e = trees.elements(); e.hasMoreElements();) {
            t = (SmbTree) e.nextElement();
            if (t.matches(share, service)) {
                return t;
            }
        }