placeholder: |
        * Open the browser and call the endpoint `/`.
        * It returns a JSON with `{"Hello": "World"}`.
        * But I expected it to return `{"Hello": "Sara"}`.
    validations:
      required: true
  - type: dropdown
    id: os
    attributes:
      label: Operating System
      description: What operating system are you on?

    }
  }

  private void checkHelperVersion(ClassLoader classLoader, String expectedHelperClassName)
      throws Exception {
    // Make sure we are actually running with the expected helper implementation
    Class<?> abstractFutureStateClass = classLoader.loadClass(AbstractFutureState.class.getName());
    Method helperMethod = abstractFutureStateClass.getDeclaredMethod("atomicHelperTypeForTest");

func TestDerivePartKey(t *testing.T) {
	var key ObjectKey
	for i, test := range derivePartKeyTest {
		expectedPartKey, err := hex.DecodeString(test.PartKey)
		if err != nil {
			t.Fatalf("Test %d failed to decode expected part-key: %v", i, err)
		}
		partKey := key.DerivePartKey(test.PartID)
		if !bytes.Equal(partKey[:], expectedPartKey) {

// inputs and outputs and the gradient function These data structures combined
// allow us to trace the data dependencies between operations and hence compute
// gradients.
//
// `ZerosLike` is not expected to be called and returns a nullptr. The creation
// of default zeros grads is handled by the `DefaultGradientFunction` registered
// for each op.
// TODO(srbs): We need to define `ZerosLike` here to keep the compiler happy.

    checkNotNull(in);
    return toByteArrayInternal(in, new ArrayDeque<byte[]>(TO_BYTE_ARRAY_DEQUE_SIZE), 0);
  }

  /**
   * Reads all bytes from an input stream into a byte array. The given expected size is used to
   * create an initial byte array, but if the actual number of bytes read from the stream differs,
   * the correct result will be returned anyway.
   */

    try {
      collection.retainAll(target.toRetain);
      String message = Platform.format("retainAll(%s) should throw", target);
      fail(message);
    } catch (UnsupportedOperationException expected) {
    }
  }

  private void expectReturnsFalseOrThrows(Target target) {
    String message = Platform.format("retainAll(%s) should return false or throw", target);
    try {

  }

  @Test fun cancelAllWhenEmptyDoesNotStartWorkerThread() {
    redQueue.execute("red task", 100.µs) {
      error("expected to be canceled")
    }
    assertThat(taskFaker.executeCallCount).isEqualTo(1)

    blueQueue.execute("task", 100.µs) {
      error("expected to be canceled")
    }
    assertThat(taskFaker.executeCallCount).isEqualTo(1)

    redQueue.cancelAll()

    @DisplayName("Test size method without input buffer")
    void testSizeWithoutInputBuffer() {
        request = new Smb2QueryInfoRequest(mockConfig);

        int size = request.size();

        // Expected size calculation: size8(SMB2_HEADER_LENGTH + 40)
        // size8 rounds up to nearest multiple of 8
        int expectedRawSize = Smb2Constants.SMB2_HEADER_LENGTH + 40;

    for (Class<?> mutableClass : mutableClasses) {
      Object instance = ArbitraryInstances.get(mutableClass);
      assertWithMessage("Expected to return non-null for: %s", mutableClass)
          .that(instance)
          .isNotNull();
      assertWithMessage("Expected to return fresh instance for: " + mutableClass)
          .that(ArbitraryInstances.get(mutableClass))
          .isNotSameInstanceAs(instance);
    }
  }

func (l *ObjectLegalHold) UnmarshalXML(d *xml.Decoder, start xml.StartElement) (err error) {
	switch start.Name.Local {
	case "LegalHold", "ObjectLockLegalHold":
	default:
		return xml.UnmarshalError(fmt.Sprintf("expected element type <LegalHold>/<ObjectLockLegalHold> but have <%s>",
			start.Name.Local))
	}
	for {
		// Read tokens from the XML document in a stream.
		t, err := d.Token()
		if err != nil {
			if err == io.EOF {