type AssociationOpType int

const (
	OpUnlink AssociationOpType = iota // Unlink association
	OpDelete                          // Delete association records
	OpUpdate                          // Update association records
	OpCreate                          // Create association records with assignments
)

// Association represents an association operation
type Association struct {
	Association string            // Association name

    response = client.post(
        "/form/python-list", data={"items": ["first", "second", "third"]}
    )
    assert response.status_code == 200, response.text
    assert response.json() == ["first", "second", "third"]


def test_python_set_param_as_form():
    response = client.post(
        "/form/python-set", data={"items": ["first", "second", "third"]}
    )
    assert response.status_code == 200, response.text

	lrwm := NewLRWMutex()

	if !lrwm.GetRLock(ctx, "", "object1", time.Second) {
		panic("Failed to acquire read lock")
	}
	// fmt.Println("1st read lock acquired, waiting...")

	if !lrwm.GetRLock(ctx, "", "object1", time.Second) {
		panic("Failed to acquire read lock")
	}
	// fmt.Println("2nd read lock acquired, waiting...")

	go func() {
		time.Sleep(2 * time.Second)
		lrwm.RUnlock()

## Architecture Standards

**Experimental!**

We'd like to capture our architectural decisions about the build tool as [Architectural Decision Records (ADRs)](https://adr.github.io/).
For now we just have this global repository of ADRs.
If we see fit, we can break these out to per-platform ones, or keep a hybrid approach to having global and platform-specific ADSs.

Our aim is to keep the process lightweight and approachable.

		records, err := c.list(key+etcdPathSeparator, true)
		if err != nil {
			return srvRecords, err
		}
		for _, record := range records {
			if record.Key == "" {
				continue
			}
			srvRecords[record.Key] = append(srvRecords[record.Key], record)
		}
	}
	return srvRecords, nil
}

// Get - Retrieves DNS records for a bucket.

import model.CIBuildModel
import model.Stage

/**
 * Build a Gradle distribution (dogfood-first) and use this distribution to build a distribution again (dogfood-second).
 * Use `dogfood-second` to run `test sanityCheck`.
 */
class Gradleception(
    model: CIBuildModel,
    stage: Stage,
    buildJvm: Jvm,
    jvmDescription: String,
    bundleGroovyMajor: Int? = null,

  static final String FIRST = "one";
  static final Double SECOND = 2.0d;

  final EventBus bus = new EventBus();

  public void testNoReentrantEvents() {
    ReentrantEventsHater hater = new ReentrantEventsHater();
    bus.register(hater);

    bus.post(FIRST);

    assertEquals(
        "ReentrantEventHater expected 2 events",
        Lists.<Object>newArrayList(FIRST, SECOND),
        hater.eventsReceived);
  }

      """
      |data: first event
      |id: 1
      |
      |data: second event
      |id
      |
      |data: third event
      |
      |
      """.trimMargin(),
    )
    assertThat(callbacks.remove()).isEqualTo(Event("1", null, "first event"))
    assertThat(callbacks.remove()).isEqualTo(Event(null, null, "second event"))
    assertThat(callbacks.remove()).isEqualTo(Event(null, null, "third event"))
  }

}

func TestDynamicTimeoutDualDecrease(t *testing.T) {
	timeout := newDynamicTimeout(time.Minute, time.Second)

	initial := timeout.Timeout()

	for range dynamicTimeoutLogSize {
		timeout.LogSuccess(20 * time.Second)
	}

	adjusted := timeout.Timeout()

	for range dynamicTimeoutLogSize {
		timeout.LogSuccess(20 * time.Second)
	}

	adjustedAgain := timeout.Timeout()

	"testing"
	"time"
)

func slowCaller(ctx context.Context) error {
	sl := time.NewTimer(time.Second)
	defer sl.Stop()

	select {
	case <-sl.C:
	case <-ctx.Done():
		return ctx.Err()
	}

	return nil
}

func TestCacheCtx(t *testing.T) {
	cache := New[time.Time]()
	t.Parallel()
	cache.InitOnce(2*time.Second, Opts{},
		func(ctx context.Context) (time.Time, error) {
			return time.Now(), slowCaller(ctx)
		},