return this;
        }

        /**
         * Returns a new ApiResult instance with this ApiResponse.
         * @return A new ApiResult instance.
         */
        public ApiResult result() {
            return new ApiResult(this);
        }
    }

    /**
     * Represents an API response for an update operation.
     */
    public static class ApiUpdateResponse extends ApiResponse {

   * contains {@link Double#NEGATIVE_INFINITY} and not {@link Double#NaN} then the result is {@link
   * Double#NEGATIVE_INFINITY}. If it contains {@link Double#POSITIVE_INFINITY} and finite values
   * only then the result is the lowest finite value. If it contains {@link
   * Double#POSITIVE_INFINITY} only then the result is {@link Double#POSITIVE_INFINITY}.
   *

    field_info = FieldInfo(annotation=Union[list[str], None])
    field = v2.ModelField(name="items", field_info=field_info)
    result = v2.serialize_sequence_value(field=field, value=["a", "b", "c"])
    assert result == ["a", "b", "c"]
    assert isinstance(result, list)


@needs_py310
def test_serialize_sequence_value_with_optional_list_pipe_union():

    assertThat(response.body.string()).isEqualTo("Hello")
  }

  private fun gzip(data: String): Buffer {
    val result = Buffer()
    val sink = GzipSink(result).buffer()
    sink.writeUtf8(data)
    sink.close()
    return result
  }

              .copy(fileName = storyResourceName)
          result.add(story)
          i++
        }
      } finally {
        storyInputStream.close()
      }
    }

    if (result.isEmpty()) {
      // missing files
      result.add(Story.MISSING)
    }

    return result
  }

	}

	// Tests generated values from url encoded name.
	for i, testCase := range testCases {
		result := signV4TrimAll(testCase.inputStr)
		if testCase.result != result {
			t.Errorf("Test %d: Expected signV4TrimAll result to be \"%s\", but found it to be \"%s\" instead", i+1, testCase.result, result)
		}
	}
}

// Test getContentSha256Cksum
func TestGetContentSha256Cksum(t *testing.T) {

  require(readByte() == '\"'.code.toByte())
  val result = Buffer()
  while (true) {
    val i = indexOfElement(QUOTED_STRING_DELIMITERS)
    if (i == -1L) return null // Unterminated quoted string.

    if (this[i] == '"'.code.toByte()) {
      result.write(this, i)
      // Consume '"'.
      readByte()
      return result.readUtf8()
    }

    if (size == i + 1L) return null // Dangling escape.

            UpgradeResult result = strategy.apply(context, pomMap);

            // Should have errors (not just warnings)
            assertTrue(result.errorCount() > 0, "Downgrade should result in errors");
            assertFalse(result.success(), "Downgrade should not be successful");
            assertEquals(1, result.errorCount(), "Should have exactly one error");
        }

        @Test

            // When
            String result = fileFsFullSizeInfo.toString();

            // Then
            assertNotNull(result);
            assertTrue(result.contains("SmbInfoAllocation"));
            assertTrue(result.contains("alloc=0"));
            assertTrue(result.contains("free=0"));
            assertTrue(result.contains("sectPerAlloc=0"));
            assertTrue(result.contains("bytesPerSect=0"));
        }

        } catch (CyclicDependencyException e) {
            result.addCircularDependencyException(e);

            return result;
        } catch (OverConstrainedVersionException e) {
            result.addVersionRangeViolation(e);

            return result;
        }

        ManagedVersionMap versionMap = getManagedVersionsMap(originatingArtifact, managedVersions);