if !reflect.DeepEqual(names, want) {
		t.Errorf("got unexpected result: %#v", names)
	}
	err = r.skip(5)
	if err != nil {
		t.Fatal(err)
	}
	names, err = r.readNames(5)
	if err != nil {
		t.Fatal(err)
	}
	want = loadMetacacheSampleNames[10:15]
	if !reflect.DeepEqual(names, want) {
		t.Errorf("got unexpected result: %#v", names)
	}

        // Test with very long classification name
        StringBuilder longName = new StringBuilder();
        for (int i = 0; i < 1000; i++) {
            longName.append("VeryLongClassificationName");
        }
        assertProvideThrowsException(longName.toString());
    }

    @Test
    public void test_provide_withUnicodeCharacters() {
        // Test classification names with Unicode characters

        assertFalse(name1.equals(name2));
    }

    @Test
    void equals_withBothNullScope_shouldReturnTrue() {
        Name name1 = new Name(mockConfig, "TEST", 0x20, null);
        name1.scope = null;
        Name name2 = new Name(mockConfig, "TEST", 0x20, null);
        name2.scope = null;

        assertTrue(name1.equals(name2));
    }

    @Test

    @JvmOverloads
    constructor(
      private val charset: Charset? = null,
    ) {
      private val names = mutableListOf<String>()
      private val values = mutableListOf<String>()

      fun add(
        name: String,
        value: String,
      ) = apply {
        names +=
          name.canonicalizeWithCharset(
            encodeSet = FORM_ENCODE_SET,

		return false
	})

	for _, c := range cs {
		// show warning message the callback name already exists
		if idx := getRIndex(names, c.name); idx > -1 && !c.replace && !c.remove && !cs[idx].remove {
			c.processor.db.Logger.Warn(context.Background(), "duplicated callback `%s` from %s\n", c.name, utils.FileWithLineNum())
		}
		names = append(names, c.name)
	}

	sortCallback = func(c *callback) error {

                    final List<String> names = new ArrayList<>();
                    for (int i = 0; i < numExpanded; i++) {
                        final String en = readString(buffer, start + expandedNameOffset, len);
                        names.add(en);
                        expandedNameOffset += en.length() * 2 + 2;
                    }
                    this.expandedNames = names.toArray(new String[names.size()]);

		sipHash    int
	}{
		// cases which should pass the test.
		// passing in valid object name.
		{"object", 37},
		{"The Shining Script <v1>.pdf", 38},
		{"Cost Benefit Analysis (2009-2010).pptx", 59},
		{"117Gn8rfHL2ACARPAhaFd0AGzic9pUbIA/5OCn5A", 35},
		{"SHØRT", 49},
		{"There are far too many object names, and far too few bucket names!", 8},
		{"a/b/c/", 159},
		{"/a/b/c", 96},
		{string([]byte{0xff, 0xfe, 0xfd}), 147},
	}

     * any of the algorithm name is not supported. The returned collection has equal count of elements as passed in
     * collection of names, and if names contains duplicated elements, the returned list of algorithms will have
     * duplicates as well.
     *
     * @throws ChecksumAlgorithmServiceException if any asked algorithm name is not supported.

			set.CreateStringSet("dep1", "dep2", "dep3", "dep4"),
			[]string{},
		},
	}

	for i, tc := range testCases {
		names := getMissingSiteNames(tc.oldDepIDs, tc.newDepIDs, tc.currSites)
		if len(names) != len(tc.expNames) {
			t.Errorf("Test %d: Expected `%v`, got `%v`", i+1, tc.expNames, names)
		}
	}

        Path confPath = ResourceUtil.getConfPath("test.conf");
        assertNotNull(confPath);

        // Test with empty names
        confPath = ResourceUtil.getConfPath();
        assertNotNull(confPath);

        // Test with multiple names
        confPath = ResourceUtil.getConfPath("dir1", "dir2", "file.conf");
        assertNotNull(confPath);