}

  @Override
  public HashCode hashInt(int input) {
    return hashBytes(ByteBuffer.allocate(4).order(ByteOrder.LITTLE_ENDIAN).putInt(input).array());
  }

  @Override
  public HashCode hashLong(long input) {
    return hashBytes(ByteBuffer.allocate(8).order(ByteOrder.LITTLE_ENDIAN).putLong(input).array());
  }

  @Override
  public HashCode hashUnencodedChars(CharSequence input) {
    int len = input.length();

    input.put("foo", 1);
    input.put("bar", 2);
    input.put("foo", 3);
    input.put("foo", 1);
    Multimap<String, Integer> multimap = ImmutableListMultimap.copyOf(input);
    assertEquals(multimap, input);
    assertEquals(input, multimap);
  }

  public void testCopyOfEmpty() {
    ArrayListMultimap<String, Integer> input = ArrayListMultimap.create();

  private static void testReverse(float[] input, float[] expectedOutput) {
    input = Arrays.copyOf(input, input.length);
    Floats.reverse(input);
    assertThat(input).isEqualTo(expectedOutput);
  }

  private static void testReverse(
      float[] input, int fromIndex, int toIndex, float[] expectedOutput) {
    input = Arrays.copyOf(input, input.length);
    Floats.reverse(input, fromIndex, toIndex);

type PReader struct {
	args        *ReaderArgs
	readCloser  io.ReadCloser   // raw input
	buf         *bufio.Reader   // input to the splitter
	current     []jstream.KVS   // current block of results to be returned
	recordsRead int             // number of records read in current slice
	input       chan *queueItem // input for workers
	queue       chan *queueItem // output from workers in order

      const std::vector<TF_Tensor*>& input_tensors,
      const absl::optional<std::vector<int64_t>>& expected_shape) {
    // Create input_shapes.
    TF_ShapeAndTypeList* input_shapes =
        TF_NewShapeAndTypeList(input_shapes_vec.size());
    for (size_t i = 0; i < input_shapes_vec.size(); ++i) {
      const auto& input_shape = input_shapes_vec[i];

				<la:form styleId="newPassword" method="post">
					<div class="input-group mb-3">
						<c:set var="ph_new_password">
							<la:message key="labels.login.placeholder_new_password" />
						</c:set>
						<la:password property="password" class="form-control"
							placeholder="${ph_new_password}" />
						<div class="input-group-append">
							<span class="input-group-text">
								<em class="fa fa-lock fa-fw">
							</span>

    @Override
    public ListenableFuture<String> apply(Integer input) throws Exception {
      switch (input) {
        case VALID_INPUT_DATA:
          outputFuture.set(RESULT_DATA);
          break;
        case SLOW_OUTPUT_VALID_INPUT_DATA:
          break; // do nothing to the result
        case SLOW_FUNC_VALID_INPUT_DATA:
          funcIsWaitingLatch.countDown();

 * @description Returns the specified value if non-null, otherwise an empty array.
 * @param {Object} input - The object to investigate
 * @returns Object - The specified value if non-null, otherwise an empty array
 * @example {{ readField('jvm', 'files') | nullToEmpty }}
 */
function nullToEmpty(input) {
    let output;
    if (input) {
        output = input;
    } else {
        output = [];
    }
    console.log("nullToEmpty: " + output);

import (
	"encoding/xml"
	"testing"
)

func TestTransitionUnmarshalXML(t *testing.T) {
	trTests := []struct {
		input string
		err   error
	}{
		{
			input: `<Transition>
			<Days>0</Days>
			<StorageClass>S3TIER-1</StorageClass>
		  </Transition>`,
			err: nil,
		},
		{
			input: `<Transition>
			<Days>1</Days>
			<Date>2021-01-01T00:00:00Z</Date>
			<StorageClass>S3TIER-1</StorageClass>

namespace gradients {
namespace {

static Status SafeConj(AbstractContext* ctx, AbstractTensorHandle* const input,
                       AbstractTensorHandle** output, const char* name) {
  auto dtype = input->DataType();
  if (DataTypeIsFloating(BaseType(dtype)) ||
      DataTypeIsInteger(BaseType(dtype))) {
    return tensorflow::ops::Identity(ctx, input, output, name);
  } else if (!DataTypeIsComplex(BaseType(dtype)) &&