text:
package feature

import (
	"context"
	"fmt"
	"io"
	"net/http"
	"net/http/httptest"
	"net/url"
	"testing"

	"go.uber.org/zap"
	"go.uber.org/zap/zaptest"
)

const (
	destBody = "hello from destination"
	srcBody  = "hello from source"
	flagKey  = "fancy-feature"
)

func TestHTTPProxy_Proxying(t *testing.T) {
	en := enabler{key: flagKey, state: true}
	logger := zaptest.NewLogger(t)
	resp, err := testHTTPProxy(logger, en)
	if err != nil {
		t.Error(err)
	}

	proxyFlag := resp.Header.Get("X-Platform-Proxy-Flag")
	if proxyFlag != flagKey {
		t.Error("X-Platform-Proxy-Flag header not populated")
	}

	body, err := io.ReadAll(resp.Body)
	if err != nil {
		t.Error(err)
	}

	bodyStr := string(body)
	if bodyStr != destBody {
		t.Errorf("expected body of destination handler, but got: %q", bodyStr)
	}
}

func TestHTTPProxy_DefaultBehavior(t *testing.T) {
	en := enabler{key: flagKey, state: false}
	logger := zaptest.NewLogger(t)
	resp, err := testHTTPProxy(logger, en)
	if err != nil {
		t.Error(err)
	}

	proxyFlag := resp.Header.Get("X-Platform-Proxy-Flag")
	if proxyFlag != "" {
		t.Error("X-Platform-Proxy-Flag header populated")
	}

	body, err := io.ReadAll(resp.Body)
	if err != nil {
		t.Error(err)
	}

	bodyStr := string(body)
	if bodyStr != srcBody {
		t.Errorf("expected body of source handler, but got: %q", bodyStr)
	}
}

func TestHTTPProxy_RequestHeader(t *testing.T) {
	h := func(w http.ResponseWriter, r *http.Request) {
		proxyFlag := r.Header.Get("X-Platform-Proxy-Flag")
		if proxyFlag != flagKey {
			t.Error("expected X-Proxy-Flag to contain feature flag key")
		}
	}

	s := httptest.NewServer(http.HandlerFunc(h))
	defer s.Close()

	sURL, err := url.Parse(s.URL)
	if err != nil {
		t.Error(err)
	}

	logger := zaptest.NewLogger(t)
	en := enabler{key: flagKey, state: true}
	proxy := NewHTTPProxy(sURL, logger, en)

	w := httptest.NewRecorder()
	r := httptest.NewRequest(http.MethodGet, "http://example.com/foo", nil)
	srcHandler(proxy)(w, r)
}

func testHTTPProxy(logger *zap.Logger, enabler ProxyEnabler) (*http.Response, error) {
	s := httptest.NewServer(http.HandlerFunc(destHandler))
	defer s.Close()

	sURL, err := url.Parse(s.URL)
	if err != nil {
		return nil, err
	}

	proxy := NewHTTPProxy(sURL, logger, enabler)

	w := httptest.NewRecorder()
	r := httptest.NewRequest(http.MethodGet, "http://example.com/foo", nil)
	srcHandler(proxy)(w, r)

	return w.Result(), nil
}

func destHandler(w http.ResponseWriter, r *http.Request) {
	fmt.Fprint(w, destBody)
}

func srcHandler(proxy *HTTPProxy) http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {
		if proxy.Do(w, r) {
			return
		}
		fmt.Fprint(w, srcBody)
	}
}

type enabler struct {
	key   string
	state bool
}

func (e enabler) Key() string {
	return e.key
}

func (e enabler) Enabled(context.Context, ...Flagger) bool {
	return e.state
}


text:
#region License Information
/*
 * This file is part of SimSharp which is licensed under the MIT license.
 * See the LICENSE file in the project root for more information.
 */
#endregion

using System;
using System.Collections.Generic;

namespace SimSharp.Samples {
  public class ProcessCommunication {
    /*
     * Process communication example
     *
     * Covers:
     *  - Resources: Store
     *
     * Scenario:
     *  This example shows how to interconnect simulation model elements
     *  together using :class:`~simpy.resources.store.Store` for one-to-one,
     *  asynchronous processes.
     */
    private IEnumerable<Event> MessageGenerator(string name, Simulation env, Store outPipe) {
      // A process which randomly generates messages.
      while (true) {
        // wait for next transmission
        yield return env.TimeoutUniformD(6, 11);

        // messages are time stamped to later check if the consumer was
        // late getting them.  Note, using event.triggered to do this may
        // result in failure due to FIFO nature of simulation yields.
        // (i.e. if at the same env.now, message_generator puts a message
        // in the pipe first and then message_consumer gets from pipe,
        // the event.triggered will be True in the other order it will be
        // False
        var msg = new object[] { env.Now, string.Format("{0} says hello at {1}", name, env.Now) };
        outPipe.Put(msg);
      }
    }

    private IEnumerable<Event> MessageConsumer(string name, Simulation env, Store inPipe) {
      // A process which consumes messages.
      while (true) {
        // Get event for message pipe
        var get = inPipe.Get();
        yield return get;
        var msg = (object[])get.Value;
        if (((DateTime)msg[0]) < env.Now) {
          // if message was already put into pipe, then
          // message_consumer was late getting to it. Depending on what
          // is being modeled this, may, or may not have some
          // significance
          env.Log("LATE Getting Message: at time {0}: {1} received message: {2}", env.Now, name, msg[1]);
        } else {
          // message_consumer is synchronized with message_generator
          env.Log("at time {0}: {1} received message: {2}.", env.Now, name, msg[1]);
        }

        // Process does some other work, which may result in missing messages
        yield return env.TimeoutUniformD(4, 9);
      }
    }

    public void Simulate(int rseed = 42) {
      // Setup and start the simulation
      var env = new Simulation(rseed, TimeSpan.FromSeconds(1));
      env.Log("== Process communication ==");

      var pipe = new Store(env);
      env.Process(MessageGenerator("Generator A", env, pipe));
      env.Process(MessageConsumer("Consumer A", env, pipe));

      env.Run(TimeSpan.FromSeconds(100));
    }
  }
}

redpajama_set_name: RedPajamaGithub