azMeta[k] = to.Ptr(v)
	}
	resp, err := az.clnt.UploadStream(ctx, az.Bucket, az.getDest(object), io.LimitReader(r, length), &azblob.UploadStreamOptions{
		Concurrency: 4,
		AccessTier:  az.tier(), // set tier if specified
		Metadata:    azMeta,
	})
	if err != nil {
		return "", azureToObjectError(err, az.Bucket, az.getDest(object))
	}
	vid := ""
	if resp.VersionID != nil {
		vid = *resp.VersionID
	}

  public void testRemoveAtIndex_unsupported() {
    assertThrows(UnsupportedOperationException.class, () -> getList().remove(0));
    expectUnchanged();
  }

  @ListFeature.Require(SUPPORTS_REMOVE_WITH_INDEX)
  public void testRemoveAtIndex_negative() {
    assertThrows(IndexOutOfBoundsException.class, () -> getList().remove(-1));
    expectUnchanged();
  }

  @ListFeature.Require(SUPPORTS_REMOVE_WITH_INDEX)

     * @throws Exception
     */
    @Test
    public void testGetLast() throws Exception {
        try {
            list.getLast();
            fail();
        } catch (final NoSuchElementException ex) {
            System.out.println(ex);
        }
        list.addLast("1");
        assertThat(list.getLast(), is("1"));
    }

    /**
     * @throws Exception
     */
    @Test

func (s3 *warmBackendS3) ToObjectError(err error, params ...string) error {
	object := ""
	if len(params) >= 1 {
		object = params[0]
	}

	return ErrorRespToObjectError(err, s3.Bucket, s3.getDest(object))
}

func (s3 *warmBackendS3) getDest(object string) string {
	destObj := object
	if s3.Prefix != "" {
		destObj = fmt.Sprintf("%s/%s", s3.Prefix, object)
	}
	return destObj
}

     * @return the field value
     * @throws IllegalAccessRuntimeException {@link IllegalAccessException} if an error occurs
     * @see #getInt(Field, Object)
     */
    public static int getInt(final Field field) throws IllegalAccessRuntimeException {
        assertArgumentNotNull("field", field);

        return getInt(field, null);
    }

    /**
     * Returns the value of a {@link Field} as an int.
     *

    assertTrue(
        "add(somePresent) should return true", getSet().addAll(MinimalCollection.of(e3(), e0())));
    expectAdded(e3());
  }

  @CollectionFeature.Require(SUPPORTS_ADD)
  public void testAddAll_withDuplicates() {
    MinimalCollection<E> elementsToAdd = MinimalCollection.of(e3(), e4(), e3(), e4());
    assertTrue("add(hasDuplicates) should return true", getSet().addAll(elementsToAdd));
    expectAdded(e3(), e4());
  }

    assertTrue(
        "addAll(allPresent) should return true", getList().addAll(MinimalCollection.of(e0())));
    expectAdded(e0());
  }

  @CollectionFeature.Require(absent = SUPPORTS_ADD)
  @CollectionSize.Require(absent = ZERO)
  public void testAddAll_unsupportedAllPresent() {
    assertThrows(
        UnsupportedOperationException.class, () -> getList().addAll(MinimalCollection.of(e0())));
    expectUnchanged();
  }

  @CollectionFeature.Require(SUPPORTS_REMOVE)
  @CollectionSize.Require(absent = ZERO)
  public void testRemove_present() {
    getSet().remove(e0());
    assertFalse(
        "After remove(present) a set should not contain the removed element.",
        getSet().contains(e0()));
  }

  @CollectionFeature.Require(SUPPORTS_REMOVE)
  @CollectionSize.Require(absent = ZERO)
  public void testRemove_present() {
    getSet().remove(e0());
    assertFalse(
        "After remove(present) a set should not contain the removed element.",
        getSet().contains(e0()));
  }

        ftpInfo = new FtpClient.FtpInfo(value, Constants.UTF_8);
        assertEquals(value, ftpInfo.toUrl());
        assertEquals("123.123.123.123:9999", ftpInfo.getCacheKey());
        assertEquals("123.123.123.123", ftpInfo.getHost());
        assertEquals(9999, ftpInfo.getPort());
        assertEquals("/", ftpInfo.getParent());
        assertNull(ftpInfo.getName());

        value = "ftp://123.123.123.123/test.txt";