Go tests

📝 Quiz: что выведет следующий код ?

package main

import "errors"

type MyError struct{}
func (MyError) Error() string { return "" }

func main() {
    var me = MyError{}
    var se = errors.New("foo")
    println(errors.As(me, &se))
}

Ответ пишите в комментариях 👇

🎯 Задача (Go, продвинутая конкуррентность; версия: Go 1.21+)

Сделай универсальную функцию обработки массива с контролем параллельности, сохранением исходного порядка результатов и мгновенной отменой при первой ошибке.

🟠Требования:
- Сигнатура:
Process[T any, R any](ctx context.Context, in []T, worker func(context.Context, T) (R, error), parallelism int) ([]R, error)
- Параллельная обработка не более parallelism задач одновременно.
- Результаты возвращаются в том же порядке, что и входной срез, даже если отдельные задачи завершаются вразнобой.
- При первой ошибке:
- немедленно отменить все ещё выполняющиеся задачи,
- вернуть первую ошибку,
- не оставить «утекших» горутин.
- Учитывать ctx.Done() и корректно завершаться по таймауту/отмене.
- Без внешних зависимостей; только стандартная библиотека.

🟠Подсказка:
- Используй context.WithCancelCause для распространения причины отмены.
- Организуй пул рабочих через буферизованный канал с задачами.
- Результаты складывай по индексу, чтобы сохранить порядок.
- Для потокозащищённой фиксации первой ошибки используй sync.Once.

Ниже — эталонная реализация и пример использования.

Код (Go 1.21+):

package main

import (
 "context"
 "errors"
 "fmt"
 "math/rand"
 "sync"
 "time"
)

type job[T any] struct {
 i   int
 val T
}

func Process[T any, R any](
 parent context.Context,
 in []T,
 worker func(context.Context, T) (R, error),
 parallelism int,
) ([]R, error) {
 if parallelism <= 0 {
  return nil, errors.New("parallelism must be > 0")
 }
 ctx, cancel := context.WithCancelCause(parent)
 defer cancel(nil)

 jobs := make(chan job[T], parallelism) // лёгкая обратная давление
 out := make([]R, len(in))

 var wg sync.WaitGroup
 var once sync.Once
 var firstErr error

 // Рабочие
 workerFn := func() {
  defer wg.Done()
  for {
   select {
   case <-ctx.Done():
    return
   case j, ok := <-jobs:
    if !ok {
     return
    }
    res, err := worker(ctx, j.val)
    if err != nil {
     once.Do(func() {
      firstErr = err
      cancel(err) // прерываем остальных
     })
     return
    }
    // Сохраняем порядок
    out[j.i] = res
   }
  }
 }

 // Старт пула
 wg.Add(parallelism)
 for k := 0; k < parallelism; k++ {
  go workerFn()
 }

 // Диспетчер задач
sendLoop:
 for i, v := range in {
  select {
  case <-ctx.Done():
   break sendLoop
  case jobs <- job[T]{i: i, val: v}:
  }
 }
 close(jobs)

 // Ждём завершения
 wg.Wait()

 // Если была отмена по ошибке — вернём её
 if firstErr != nil {
  return nil, firstErr
 }
 // Если отменил родительский контекст — вернём его причину
 if err := context.Cause(ctx); err != nil && !errors.Is(err, context.Canceled) && !errors.Is(err, context.DeadlineExceeded) {
  // это cause из cancel(err), уже обработали выше
 } else if err := context.Cause(parent); err != nil {
  return nil, err
 }

 return out, nil
}

// Демонстрация: умножаем числа с случайной задержкой; каждое третье число — ошибка.
// Видно, что вывод упорядочен по входу, а отмена срабатывает на первой ошибке.
func main() {
 rand.New(rand.NewSource(time.Now().UnixNano()))
 ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second)
 defer cancel()

 input := []int{1, 2, 3, 4, 5, 6, 7}
 parallelism := 3

 worker := func(ctx context.Context, x int) (int, error) {
  // эмуляция непредсказуемого времени работы
  time.Sleep(time.Duration(rand.Intn(120)) * time.Millisecond)
  if x%7 == 0 { // попробуй поменять условие на (x%3==0), чтобы увидеть раннюю отмену
   return 0, fmt.Errorf("bad luck on %d", x)
  }
  select {
  case <-ctx.Done():
   return 0, ctx.Err()
  default:
   return x * x, nil
  }
 }

 res, err := Process[int, int](ctx, input, worker, parallelism)
 if err != nil {
  fmt.Println("error:", err)
  return
 }
 fmt.Println("results:", res)
}

🟠Как проверить:
- go run . — запусти несколько раз, чтобы увидеть разные порядки завершения, но стабильный порядок результатов.
- Поменяй порог ошибки в worker (например, x%3==0), чтобы убедиться, что отмена срабатывает мгновенно и горутины не висят.
- Проверь на гонки: go run -race .

#golang #quiz: Что выведет код и почему?

🔎 Задача на Go с подвохом

Код:

package main

import "fmt"

func main() {
    s := make([]int, 3, 4) // Длина 3, capacity 4
    s[0], s[1], s[2] = 1, 2, 3
    modifySlice(s)
    fmt.Println(s)
}

func modifySlice(s []int) {
    s = append(s, 4)
    s[0] = 100
}

Вопрос: Что выведет этот код?

Варианты ответа:

A. [1 2 3]
B. [100 2 3]
C. [1 2 3 4]
D. [100 2 3 4]

Правильный ответ: B

Объяснение:
1. Создается срез с длиной 3 и capacity 4, заполненный значениями [1, 2, 3]
2. При передаче в функцию modifySlice:
— append добавляет элемент 4, но не вызывает переаллокацию
— Изменение s[0] = 100 применяется к тому же underlying массиву
3. Однако исходный срез в main() останется длины 3, но первый элемент изменится:
— Длина среза в main не меняется
— Но изменения элементов видны, так как используется тот же массив

@golang_interview

👣 Вышел Go 1.25.0!

- Release notes: https://go.dev/doc/go1.25
- Скачать: https://go.dev/dl/#go1.25.0

Здесь можно посмотреть интерактивную версию релиза с множеством примеров, показывающих, новые фичи и посмотоеть как они работают

@golang_google

👣 Напишите в комментариях, что выведет код и почему?

package main

import (
 "fmt"
)

func tricky() (err error) {
 defer func() {
  fmt.Println("D1:", err) // состояние именованного результата до recover
  if r := recover(); r != nil {
   err = fmt.Errorf("recovered: %v", r)
  }
  fmt.Println("D2:", err) // состояние после recover
 }()

 defer func() {
  panic(2) // паника №2 во время размотки стека
 }()

 panic(1) // паника №1
}

func main() {
 fmt.Println("start")
 fmt.Println("ret:", tricky())
 fmt.Println("end")
}

Вопросы:
🟠Какой будет порядок строк start, D1: ..., D2: ..., ret: ..., end?
🟠Какое значение попадёт в err и что напечатает fmt.Println("ret:", ...)?
🟠Почему паника из второго defer меняет исход паники?

@golangtests

✅ В Go можно запускать тесты без единой внешней библиотеки — всё встроено из коробки!
Вот как протестировать код в 3 шага:

1️⃣ Создай файл с суффиксом _test.go — например, sum_test.go
2️⃣ Импортируй пакет testing и напиши функцию вида: TestXxx(t *testing.T)
3️⃣ Запусти тесты командой: go test

Никаких зависимостей. Никаких настроек. Просто пиши код и проверяй его сразу.

#golang #testing #unittest