list.add("item2");
        TestAccessResultData<String> listData = new TestAccessResultData<>(list.toString().getBytes());
        Object retrievedList = testTransformer.getData(listData);
        assertEquals(list.toString(), retrievedList);

        // Null data
        TestAccessResultData<Object> nullData = new TestAccessResultData<>();
        assertNull(testTransformer.getData(nullData));
    }

    /**

        if (str == null) {
            return null;
        }
        return new String[] { str };
    }

    protected LocalDateTime toLocalDateTime(Object value) {
        return DfTypeUtil.toLocalDateTime(value);
    }

    protected Date toDate(Object value) {
        return DfTypeUtil.toDate(value);
    }

    protected SearchHits getSearchHits(final SearchResponse response) {

   * {@link #valueField} of {@code future}.
   */
  static boolean casValue(AbstractFutureState<?> future, @Nullable Object expect, Object update) {
    return ATOMIC_HELPER.casValue(future, expect, update);
  }

  /** Returns the value of the future, using a volatile read. */
  final @Nullable Object value() {
    return valueField;
  }

  /** Returns the head of the listener stack, using a volatile read. */

        try {
            String username = "testuser";
            String password = "testpass";
            server = startFtpServer(FTP_PORT, username, password);
            Map<String, Object> params = new HashMap<String, Object>();
            FtpAuthentication auth = new FtpAuthentication();
            auth.setUsername(username);
            auth.setPassword(password);

   *
   * @throws UnsupportedOperationException always
   * @deprecated <b>Pass keys of type {@code Comparable} to use {@link
   *     ImmutableSortedMap#of(Comparable, Object, Comparable, Object, Comparable, Object,
   *     Comparable, Object, Comparable, Object)}.</b>
   */
  @DoNotCall("Pass keys of type Comparable")
  @Deprecated
  public static <K, V> ImmutableSortedMap<K, V> of(

                    "title": "OtherItem",
                    "required": ["price"],
                    "type": "object",
                    "properties": {"price": {"title": "Price", "type": "integer"}},
                },
                "Item": {
                    "title": "Item",
                    "type": "object",
                    "properties": {
                        "name": {
                            "title": "Name",

                    "required": ["message"],
                    "type": "object",
                    "properties": {"message": {"title": "Message", "type": "string"}},
                },
                "ValidationError": {
                    "title": "ValidationError",
                    "required": ["loc", "msg", "type"],
                    "type": "object",
                    "properties": {
                        "loc": {

	// Fast exit track to check if we are listing an object with
	// a trailing slash, this will avoid to list the object content.
	if HasSuffix(opts.BaseDir, SlashSeparator) {
		metadata, err := s.readMetadata(ctx, pathJoin(volumeDir,
			opts.BaseDir[:len(opts.BaseDir)-1]+globalDirSuffix,
			xlStorageFormatFile))
		diskHealthCheckOK(ctx, err)
		if err == nil {
			// if baseDir is already a directory object, consider it

      }

      @Override
      public V next() {
        return entryItr.next().getValue();
      }
    };
  }

  @Override
  public boolean contains(@Nullable Object object) {
    return object != null && Iterators.contains(iterator(), object);
  }

  @Override
  boolean isPartialView() {
    return true;
  }

  @Override
  public ImmutableList<V> asList() {

            "schemas": {
                "Body_create_file_files__post": {
                    "title": "Body_create_file_files__post",
                    "required": ["file", "fileb", "token"],
                    "type": "object",
                    "properties": {
                        "file": {"title": "File", "type": "string", "format": "binary"},
                        "fileb": {
                            "title": "Fileb",