}

    def "runs side effect when calling '#method' on changing provider"() {
        given:
        def sideEffect = Mock(ValueSupplier.SideEffect)
        def counter = new AtomicInteger(23)
        def parent = Providers.changing { counter.getAndIncrement() }
        def provider = parent.withSideEffect(sideEffect)

        when:
        provider.calculateValue(ValueSupplier.ValueConsumer.IgnoreUnsafeRead)

	}
}

type fakeResponseWriterDecorator struct {
	http.ResponseWriter
	counter *counter
}

func (fw *fakeResponseWriterDecorator) Unwrap() http.ResponseWriter { return fw.ResponseWriter }
func (fw *fakeResponseWriterDecorator) Flush() {
	if fw.counter != nil {
		fw.counter.FlushInvoked++
	}
	fw.ResponseWriter.(http.Flusher).Flush()
}

)

type mockRand struct {
	values  []int
	counter int
	b       bool
}

func (mr *mockRand) uint32() uint32 {
	c := mr.values[mr.counter]
	mr.counter++
	return uint32(c)
}

func (mr *mockRand) intn(n int) int {
	c := mr.values[mr.counter]
	mr.counter++
	return c % n
}

func (mr *mockRand) uint32n(n uint32) uint32 {
	c := mr.values[mr.counter]
	mr.counter++
	return uint32(c) % n
}

		g.cipher.Encrypt(mask[:], counter[:])
		gcmInc32(counter)
		subtle.XORBytes(out, in, mask[:])
	}
}

// deriveCounter computes the initial GCM counter state from the given nonce.
// See NIST SP 800-38D, section 7.1. This assumes that counter is filled with
// zeros on entry.
func (g *gcm) deriveCounter(counter *[gcmBlockSize]byte, nonce []byte) {
	// GCM has two modes of operation with respect to the initial counter

	if !exists {
		throw("runtime.Pinner: decreased non-existing pin counter")
	}
	counter := (*specialPinCounter)(unsafe.Pointer(*ref))
	counter.counter--
	if counter.counter == 0 {
		*ref = counter.special.next
		if span.specials == nil {
			spanHasNoSpecials(span)
		}
		lock(&mheap_.speciallock)
		mheap_.specialPinCounterAlloc.free(unsafe.Pointer(counter))
		unlock(&mheap_.speciallock)
		return false
	}

	blockCipher, err := aes.NewCipher(r.key[:])
	if err != nil {
		r.mu.Unlock()
		return 0, err
	}
	var (
		counter uint64
		block   [aes.BlockSize]byte
	)
	inc := func() {
		counter++
		if counter == 0 {
			panic("crypto/rand counter wrapped")
		}
		byteorder.LePutUint64(block[:], counter)
	}
	blockCipher.Encrypt(r.key[:aes.BlockSize], block[:])
	inc()
	blockCipher.Encrypt(r.key[aes.BlockSize:], block[:])

	}
	if av, bv := <-a, <-b; av|bv != 3 {
		println("bad values", av, bv)
		panic("fail")
	}
	if v := Send(a, nil); v != 1 {
		println("Send returned", v, "!= 1")
		panic("fail")
	}
	if counter != 10 {
		println("counter is", counter, "!= 10")
		panic("fail")
	}

    }

    private static String create(String counter, String value, BigDecimal minimum, BigDecimal maximum) {
        StringBuilder limit = new StringBuilder()
        limit <<= 'limit {\n'

        if (counter) {
            limit <<= "    counter = '${counter}'\n"
        }
        if (value) {
            limit <<= "    value = '${value}'\n"
        }

}

func (c *totalPluginsCollector) getPluginCount() pluginCount {
	counter := make(pluginCount)
	for _, registeredPlugin := range c.asw.GetRegisteredPlugins() {
		socketPath := registeredPlugin.SocketPath
		counter.add("actual_state_of_world", socketPath)
	}

	for _, pluginToRegister := range c.dsw.GetPluginsToRegister() {
		socketPath := pluginToRegister.SocketPath
		counter.add("desired_state_of_world", socketPath)
	}
	return counter

      void doIt(ImmutableDoubleArray.Builder builder, AtomicInteger counter) {
        builder.add(counter.getAndIncrement());
      }
    },
    ADD_ARRAY {
      @Override
      void doIt(ImmutableDoubleArray.Builder builder, AtomicInteger counter) {
        double[] array = new double[RANDOM.nextInt(10)];
        for (int i = 0; i < array.length; i++) {
          array[i] = counter.getAndIncrement();
        }