}

    @Test
    @DisplayName("Test split returns null")
    void testSplit() {
        // Given
        Smb2CancelRequest request = new Smb2CancelRequest(mockConfig, 1L, 0L);

        // When
        CommonServerMessageBlockRequest splitRequest = request.split();

        // Then
        assertNull(splitRequest, "Cancel requests cannot be split");
    }

    @Test

     * which to start, and using expressions split at the dot ('.') to navigate
     * the object graph beneath this root.
     * @param root the root of the graph.
     */
    public ObjectBasedValueSource(Object root) {
        super(true);
        this.root = root;
    }

    /**
     * <p>Split the expression into parts, tokenized on the dot ('.') character. Then,

        final String value = config.getInitParameter(ENCODING_MAP);
        if (StringUtil.isNotBlank(value)) {
            final String[] encodingPairs = value.split(",");
            for (final String pair : encodingPairs) {
                final String[] encInfos = pair.trim().split(":");
                if (encInfos.length == 2) {
                    encodingMap.put("/" + encInfos[0] + "/", encInfos[1]);
                }
            }

	for range b.N {
		for range SplitSeq(benchInputHard, nil) {
		}
	}
}

func BenchmarkSplitSeqSingleByteSeparator(b *testing.B) {
	sep := []byte("/")
	for range b.N {
		for range SplitSeq(benchInputHard, sep) {
		}
	}
}

func BenchmarkSplitSeqMultiByteSeparator(b *testing.B) {
	sep := []byte("hello")
	for range b.N {
		for range SplitSeq(benchInputHard, sep) {
		}
	}
}

        if (WILDCARD.equals(pattern) || pattern.equals(originalId)) {
            result = true;
        } else {
            // process the list
            String[] repos = pattern.split(",");
            for (String repo : repos) {
                repo = repo.trim();
                // see if this is a negative match
                if (repo.length() > 1 && repo.startsWith("!")) {

def get_body_model_name(openapi: dict[str, Any], path: str) -> str:
    body = openapi["paths"][path]["post"]["requestBody"]
    body_schema = body["content"]["application/json"]["schema"]

	if err != nil {
		if ee, ok := err.(*exec.ExitError); ok && len(ee.Stderr) > 0 {
			return errorf("%v: %s", cmd, ee.Stderr)
		}
		return errorf("%v: %w", cmd, err)
	}

	parts := strings.SplitN(string(bytes.TrimSpace(out)), ":", 4)
	if len(parts) < 2 {
		return errorf("%v: missing ':' in output: %q", cmd, out)
	}
	importPath = parts[0]
	if importPath == "" || importPath == "." {

            # no idea why, so, let's just modify the existing one
            # new_section = Section(title=new_title, children=new_children)
            item.title = new_title.split("{ #")[0]
            item.children = new_children
            new_items.append(item)
        else:
            new_items.append(item)
    return new_items


def on_nav(

        return line.replace(projectDependencyRegex) { match ->
            val projectName = match.groupValues[1]
            val parts = projectName.split(":").last().split("-")
            "projects.${parts.first()}${parts.drop(1).joinToString("") { it.replaceFirstChar { c -> c.uppercaseChar() } }}"
        }
    }

// for multipart checksum
func TestChecksumSerializeDeserializeMultiPart(t *testing.T) {
	// Create dummy data that we'll split into 3 parts
	dummyData := []byte("The quick brown fox jumps over the lazy dog. " +
		"Pack my box with five dozen brown eggs. " +
		"Have another go it will all make sense in the end!")

	// Split data into 3 parts
	partSize := len(dummyData) / 3
	part1Data := dummyData[0:partSize]