// GitHub actions for contributor PRs use a public Build Scan instance
            // in this case we need to explicitly configure the PTS server
            // Don't move this line into the lambda as it may cause config cache problems
            extensions.findByType<DevelocityTestConfiguration>()?.predictiveTestSelection {
                this as PredictiveTestSelectionConfigurationInternal

	# There are 8 disks on each node with EC:4 and two erasure sets.
	# We should be able to safely suspend one disk per set from each server.
	# suspending one additional disk from each set should cause failures
	docker exec resiliency-minio1-1 /bin/sh -c "mv /data1/.minio.sys /data1/.minio.bkp && touch /data1/.minio.sys"
	docker exec resiliency-minio2-1 /bin/sh -c "mv /data1/.minio.sys /data1/.minio.bkp && touch /data1/.minio.sys"

	}
	return nil
}

// updates rebalance.bin from let's say 2 pool setup in the middle
// of a rebalance, was expanded can cause z.rebalMeta to be outdated
// due to a missing new pool. This function tries to handle this
// scenario, albeit rare it seems to have occurred in the wild.
//
// since we do not explicitly disallow it, but it is okay for them

					c.connChange.L.Unlock()
					return
				}
			case <-ctx.Done():
				c.connChange.L.Unlock()
				return
			}
		}
	}()

	for {
		select {
		case <-ctx.Done():
			return context.Cause(ctx)
		case newState := <-changed:
			if newState == StateConnected {
				return nil
			}
		}
	}
}

/*
var ErrDone = errors.New("done for now")

synchronized class ExceptionUtils { static final String WRAPPED_MARKER = [wrapped] ; protected static String[] CAUSE_METHOD_NAMES; protected void ExceptionUtils(); public static void addCauseMethodName(String); public static Throwable getCause(Throwable); public static Throwable getCause(Throwable, String[]); public static Throwable getRootCause(Throwable); private static Throwable getCauseUsingWellKno(Throwable); private static Throwable getCauseUsingMethodN(Throwable, String); private static Throwable get...

	}
}

type dataAndEOFReader string

func (r dataAndEOFReader) Read(p []byte) (int, error) {
	return copy(p, r), io.EOF
}

func TestPeekThenUnreadRune(t *testing.T) {
	// This sequence used to cause a crash.
	r := NewReader(strings.NewReader("x"))
	r.ReadRune()
	r.Peek(1)
	r.UnreadRune()
	r.ReadRune() // Used to panic here
}

var testOutput = []byte("0123456789abcdefghijklmnopqrstuvwxy")

					time.Sleep(wait)
				}
			}()
		}
		wk.Wait()
		// Do not need to retry if we can't list objects on source.
		if context.Cause(ctx) != nil {
			return context.Cause(ctx)
		}
		ri.RetryAttempts = attempts
		ri.Complete = ri.ObjectsFailed == 0
		ri.Failed = ri.ObjectsFailed > 0

		globalBatchJobsMetrics.save(job.ID, ri)

Nope ! C'est ça la morale de l'histoire.

La concurrence est différente du parallélisme. C'est mieux sur des scénarios **spécifiques** qui impliquent beaucoup d'attente. À cause de ça, c'est généralement bien meilleur que le parallélisme pour le développement d'applications web. Mais pas pour tout.

Donc pour équilibrer tout ça, imaginez l'histoire suivante :

pkg bytes, func Clone([]uint8) []uint8 #45038
pkg bytes, func CutPrefix([]uint8, []uint8) ([]uint8, bool) #42537
pkg bytes, func CutSuffix([]uint8, []uint8) ([]uint8, bool) #42537
pkg context, func Cause(Context) error #51365
pkg context, func WithCancelCause(Context) (Context, CancelCauseFunc) #51365
pkg context, type CancelCauseFunc func(error) #51365
pkg crypto/ecdh, func P256() Curve #52221