* Adds a query command to the processor.
     *
     * @param name the name to associate with the command (typically the query class simple name)
     * @param queryCommand the query command implementation to add
     * @throws IllegalArgumentException if name or queryCommand is null
     */
    public void add(final String name, final QueryCommand queryCommand) {
        if (name == null || queryCommand == null) {

    private static final class StubFileEntry implements FileEntry {
        private final String name;
        private final int type;

        StubFileEntry(String name, int type) {
            this.name = name;
            this.type = type;
        }

        @Override
        public String getName() {
            return name;
        }

        @Override
        public int getType() {
            return type;

                      map.put(entry.getKey(), entry.getValue());
                    }
                    return map;
                  }
                })
            .named("CompactLinkedHashMap")
            .withFeatures(
                CollectionSize.ANY,
                CollectionFeature.SUPPORTS_ITERATOR_REMOVE,
                MapFeature.GENERAL_PURPOSE,

    /**
     * Share type constant for disk shares (file shares).
     */
    public static final byte SMB2_SHARE_TYPE_DISK = 0x1;
    /**
     * Share type constant for named pipe shares (IPC).
     */
    public static final byte SMB2_SHARE_TYPE_PIPE = 0x2;
    /**
     * Share type constant for printer shares.
     */
    public static final byte SMB2_SHARE_TYPE_PRINT = 0x3;

    /**

			isDir := len(file.Name) > 0 && file.Name[len(file.Name)-1] == '/'
			name := toValidName(file.Name)
			if name == "" {
				continue
			}

			if idx, ok := files[name]; ok {
				r.fileList[idx].isDup = true
				continue
			}
			if idx, ok := knownDirs[name]; ok {
				r.fileList[idx].isDup = true
				continue
			}

			for dir := path.Dir(name); dir != "."; dir = path.Dir(dir) {

	var buf bytes.Buffer
	tw := tar.NewWriter(&buf)
	var files = []struct {
		Name, Body string
	}{
		{"readme.txt", "This archive contains some text files."},
		{"gopher.txt", "Gopher names:\nGeorge\nGeoffrey\nGonzo"},
		{"todo.txt", "Get animal handling license."},
	}
	for _, file := range files {
		hdr := &tar.Header{
			Name: file.Name,
			Mode: 0600,
			Size: int64(len(file.Body)),
		}

 * The query is optional: it can be null, empty, or non-empty. For many HTTP URLs the query string
 * is subdivided into a collection of name-value parameters. This class offers methods to set the
 * query as the single string, or as individual name-value parameters. With name-value parameters
 * the values are optional and names may be repeated.
 *
 * ### Fragment
 *

	}
	for i := riscv.REG_F0; i <= riscv.REG_F31; i++ {
		name := fmt.Sprintf("F%d", i-riscv.REG_F0)
		register[name] = int16(i)
	}
	for i := riscv.REG_V0; i <= riscv.REG_V31; i++ {
		name := fmt.Sprintf("V%d", i-riscv.REG_V0)
		register[name] = int16(i)
	}

	// General registers with ABI names.
	register["ZERO"] = riscv.REG_ZERO
	register["RA"] = riscv.REG_RA
	register["SP"] = riscv.REG_SP

        assertEquals(0, info.hashCode()); // Empty string has hashCode of 0
    }

    @Test
    @DisplayName("Test with special characters in names")
    void testWithSpecialCharacters() {
        String specialName = "Share$\\Special/Name:*?";
        String specialRemark = "Remark with\nnewline\tand\rtabs";

        SmbShareInfo info = new SmbShareInfo(specialName, 0, specialRemark);

 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 */
package org.apache.maven.repository.legacy;

import javax.inject.Named;
import javax.inject.Singleton;

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.RandomAccessFile;
import java.nio.channels.Channels;