synchronized void insert(final String path, final DfsReferral dr) {
        int s1, s2;
        String server, share, key;

        if (DISABLED) {
            return;
        }

        s1 = path.indexOf('\\', 1);
        s2 = path.indexOf('\\', s1 + 1);
        server = path.substring(1, s1);
        share = path.substring(s1 + 1, s2);

        key = path.substring(0, dr.pathConsumed).toLowerCase();

    /**
     * Get the domain this referral is for
     *
     * @return the domain this referral is for
     */
    String getDomain();

    /**
     * Get the share this referral points to
     *
     * @return the share this referral points to
     */
    String getShare();

    /**
     * Get the number of characters from the UNC path that were consumed by this referral
     *

// `shape_inference::InferenceContext` constructor. Note the following:
//   - The inputs of the `op` are not used for shape inference. So, it is
//     OK to not have the inputs properly set in `op`. See `input_tensors`
//     if you want shape inference to consider the input tensors of the
//     op for shape inference.
//   - The types need not be set in `input_shapes` as it is not used.

        // The getEntries method returns FileEntry objects. We can check their names.
        assertEquals("\\domain\share1", entries[0].getName(), "The name of the first share should be correct.");
        assertEquals("\\domain\share2", entries[1].getName(), "The name of the second share should be correct.");
    }

    /**
     * Test the getEntries() method when the DfsEnumArray200 is empty.
     * Verifies that an empty array is returned.

        return this.sessionKey;
    }

    @Override
    public SmbTreeImpl getSmbTree(String share, String service) {
        if (share == null) {
            share = "IPC$";
        }

        synchronized (this.trees) {
            for (SmbTreeImpl t : this.trees) {
                if (t.matches(share, service)) {
                    return t.acquire();
                }
            }

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) {

    void happyPath_enumerates_and_closes(String wildcard) throws Exception {
        // Setup required for this test
        when(parent.getLocator()).thenReturn(locator);
        when(locator.getUNCPath()).thenReturn("\\\\server\\share\\dir\\");
        when(tree.getConfig()).thenReturn(config);
        when(config.getMaximumBufferSize()).thenReturn(65535);
        when(config.getListSize()).thenReturn(65535);

            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) {

     * the share permissions on the share exporting this file or directory.
     * If no DACL is present, null is returned. If the DACL is empty, an array with 0 elements is returned.
     * <p>
     * Note that this is different from calling <code>getSecurity</code> on a
     * share. There are actually two different ACLs for shares - the ACL on
     * the share and the ACL on the folder being shared.

// setting a shape of [-1, 2] with an existing shape [2, -1] would set
// a final shape of [2, 2] based on shape merging semantics.
//
// Returns an error into `status` if:
//   * `output` is not in `graph`.
//   * An invalid shape is being set (e.g., the shape being set
//     is incompatible with the existing shape).
TF_CAPI_EXPORT extern void TF_GraphSetTensorShape(TF_Graph* graph,