type DataProcessor interface {
    ProcessUserData(userData string) (string, error)
}

type UserService struct {
    processor DataProcessor
}

func (s *UserService) ProcessMultipleUsers(users []string) []string {
    results := make([]string, len(users))
    var wg sync.WaitGroup

    for i, user := range users {
        wg.Add(1)
        go func(index int, userData string) {
            defer wg.Done()
            result, _ := s.processor.ProcessUserData(userData)
            results[index] = result
        }(i, user)
    }

    wg.Wait()
    return results
}

func TestProcessMultipleUsers(t *testing.T) {
    ctrl := gomock.NewController(t)
    defer ctrl.Finish()

    mockProcessor := NewMockDataProcessor(ctrl)

    // Handle concurrent calls
    mockProcessor.EXPECT().
        ProcessUserData(gomock.Any()).
        Times(3).  // Expect 3 concurrent calls
        DoAndReturn(func(userData string) (string, error) {
            time.Sleep(10 * time.Millisecond) // Simulate work
            return "processed_" + userData, nil
        })

    service := &UserService{processor: mockProcessor}
    results := service.ProcessMultipleUsers([]string{"user1", "user2", "user3"})

    // Verify results
    for i, result := range results {
        if !strings.HasPrefix(result, "processed_user") {
            t.Errorf("Unexpected result for index %d: %s", i, result)
        }
    }
}

mockProcessor.EXPECT().
    ProcessUserData(gomock.Any()).
    DoAndReturn(func(userData string) (string, error) {
        time.Sleep(2 * time.Second) // Simulate slow processing
        return "", errors.New("timeout")
    })

var mu sync.Mutex
var callOrder []string

mockProcessor.EXPECT().
    ProcessUserData(gomock.Any()).
    AnyTimes().
    DoAndReturn(func(userData string) (string, error) {
        mu.Lock()
        callOrder = append(callOrder, userData)
        mu.Unlock()
        return "processed", nil
    })

mockProcessor.EXPECT().
    ProcessUserData(gomock.Any()).
    AnyTimes().
    Return("", errors.New("simulated error"))