int bytesRead = response.readDataWireFormat(buffer, start, buffer.length);

        // Verify results
        assertTrue(bytesRead > 0);
        FileEntry[] results = getResults(response);
        assertNotNull(results);
        assertEquals(1, results.length);

        SmbShareInfo share = (SmbShareInfo) results[0];
        assertEquals(shareName, share.netName);
        assertEquals(shareType, share.type);

    }

    /**
     * Success with warnings
     *
     * @param model
     * @param results
     */
    public static <T> Result<T> success(T model, Result<?>... results) {
        final List<ModelProblem> problemsList = new ArrayList<>();

        for (Result<?> result1 : results) {
            for (ModelProblem modelProblem : result1.getProblems()) {
                problemsList.add(modelProblem);

     * @param partialResults whether the results are partial due to timeout or other constraints
     * @param facetResponse the facet information for the search results
     * @param start the starting position for pagination
     * @param pageSize the size of the current page
     * @param offset the offset applied to the results
     * @return QueryResponseList containing the search results and metadata
     */

				enableMultipart: opts.enableMultipart,
				creds:           opts.creds,
			}

			results := globalNotificationSys.SpeedTest(ctx, sopts)
			sort.Slice(results, func(i, j int) bool {
				return results[i].Endpoint < results[j].Endpoint
			})

			totalPut := uint64(0)
			totalGet := uint64(0)
			for _, result := range results {
				totalPut += result.Uploads
				totalGet += result.Downloads
			}

		t.Fatalf("failed to parse user unique, got error %v", err)
	}
	constraints := user.ParseUniqueConstraints()

	results := map[string]schema.UniqueConstraint{
		"uni_user_uniques_name1": {
			Name:  "uni_user_uniques_name1",
			Field: &schema.Field{Name: "Name1", Unique: true},
		},
	}
	for k, result := range results {
		v, ok := constraints[k]
		if !ok {

	}

	var results []result
	DB.Table("users").Select("name, age").Where("id in ?", []uint{user2.ID, user3.ID}).Scan(&results)

	sort.Slice(results, func(i, j int) bool {
		return strings.Compare(results[i].Name, results[j].Name) <= -1
	})

	if len(results) != 2 || results[0].Name != user2.Name || results[1].Name != user3.Name {
		t.Errorf("Scan into struct map, got %#v", results)
	}

                }

                // Convert the input and collect results
                final List<String> results = converter.convert(input, field, lang);
                if (results == null) {
                    continue;
                }
                for (final String result : results) {
                    // Skip null results
                    if (result == null) {
                        continue;

	}

	datas := []struct {
		callbacks []callback
		err       string
		results   []string
	}{
		{
			callbacks: []callback{{h: c1}, {h: c2}, {h: c3}, {h: c4}, {h: c5}},
			results:   []string{"c1", "c2", "c3", "c4", "c5"},
		},
		{
			callbacks: []callback{{h: c1}, {h: c2}, {h: c3}, {h: c4}, {h: c5, before: "c4"}},
			results:   []string{"c1", "c2", "c3", "c5", "c4"},
		},
		{

            processor.init();

            // Should handle exception gracefully and return results from working searcher
            final List<Map<String, Object>> results = processor.search("*", new TestSearchRequestParams(0, 10, 0), OptionalThing.empty());
            assertNotNull(results);
        }
    }

    /**
     * Test handling of searcher that throws FessSystemException.
     */
    @Test

    private final List<RequestResult<?, ?>> results;

    /**
     * Constructs a new BatchRequestException with the specified message and results.
     *
     * @param <REQ> The type of the request
     * @param <REP> The type of the response
     * @param message The error message describing the batch operation failure
     * @param allResults List of results from all attempted requests in the batch
     */