1<<63 - 1,
		} {
			if c>>(n-1) != 0 {
				continue // not appropriate for the given n.
			}
			if !sdivisibleOK(n, int64(c)) {
				t.Errorf("expected n=%d c=%d to pass\n", n, c)
			}
			k := sdivisible(n, int64(c)).k
			m := sdivisible(n, int64(c)).m
			a := sdivisible(n, int64(c)).a
			max := sdivisible(n, int64(c)).max
			mask := ^uint64(0) >> (64 - n)

			C := new(big.Int).SetInt64(c)

	errTests := []struct {
		name          string
		newDeployment *apps.Deployment
		oldDeployment *apps.Deployment
	}{
		{
			name:          "validation on an existing deployment with divisible hugepages values to a new deployment with indivisible hugepages values",
			newDeployment: newDeploymentWithHugePageValue(api.ResourceHugePagesPrefix+"2Mi", resource.MustParse("2.1Mi")),

        when:
        renderer.onOutput(userInputRequestEvent)

        then:
        1 * console.getBuildProgressArea() >> buildProgressArea
        1 * buildProgressArea.setVisible(false)
        1 * console.flush()

        and:
        0 * console._
        0 * listener.onOutput(_)
        0 * prompt._
        0 * textArea._
        0 * userInput._
        renderer.eventQueue.empty

    // TODO(ew): Consider whether this belongs in Console or here
    StyledLabel getProgressBar();
    List<StyledLabel> getBuildProgressLabels();
    void resizeBuildProgressTo(int numberOfLabels);
    void setVisible(boolean isVisible);

func Generate(ch chan<- int) {
	for i := 2; ; i++ {
		ch <- i // Send 'i' to channel 'ch'.
	}
}

// Copy the values from channel 'in' to channel 'out',
// removing those divisible by 'prime'.
func Filter(in <-chan int, out chan<- int, prime int) {
	for {
		i := <-in // Receive value of new variable 'i' from 'in'.
		if i%prime != 0 {
			out <- i // Send 'i' to channel 'out'.
		}
	}
}

// tag::snippet[]
public class DataProcessingPlugin implements Plugin<Project> {
    public void apply(Project project) {
        Configuration dataFiles = project.getConfigurations().create("dataFiles", c -> {
            c.setVisible(false);
            c.setCanBeConsumed(false);
            c.setCanBeResolved(true);
            c.setDescription("The data artifacts to be processed for this plugin.");

        fillArea()

        when:
        progressArea.setVisible(false)
        redraw()

        then:
        0 * ansi._
    }

    def "doesn't scroll the area when visibility is set to false"() {
        given:
        fillArea()
        def absoluteDeltaRow = 2

        when:
        redraw()
        progressArea.setVisible(false)
        progressArea.scrollDownBy(absoluteDeltaRow)

	"testing"
)

func Benchmark_bucketMetacache_findCache(b *testing.B) {
	bm := newBucketMetacache("", false)
	const elements = 50000
	const paths = 100
	if elements%paths != 0 {
		b.Fatal("elements must be divisible by the number of paths")
	}
	var pathNames [paths]string
	for i := range pathNames[:] {
		pathNames[i] = fmt.Sprintf("prefix/%d", i)
	}
	for i := 0; i < elements; i++ {
		bm.findCache(listPathOptions{

// tag::snippet[]
public class DataProcessingPlugin implements Plugin<Project> {
    public void apply(Project project) {
        Configuration dataFiles = project.getConfigurations().create("dataFiles", c -> {
            c.setVisible(false);
            c.setCanBeConsumed(false);
            c.setCanBeResolved(true);
            c.setDescription("The data artifacts to be processed for this plugin.");

        }
    }

    public boolean isVisible() {
        return isVisible;
    }

    @Override
    public void setVisible(boolean isVisible) {
        this.isVisible = isVisible;
        for (DefaultRedrawableLabel label : entries) {
            label.setVisible(isVisible);
        }
    }

    public boolean isOverlappingWith(Cursor cursor) {
        for (DefaultRedrawableLabel label : entries) {