{"id":2,"title":"Second Record","desc":"another text","numbers":[2,3,4]}`,
		},
		{
			name:       "indexed-list-match",
			query:      `SELECT * from s3object s WHERE (7,8.5,9) IN s.nested[1]`,
			wantResult: ``,
		},
		{
			name:       "indexed-list-match-equals",
			query:      `SELECT * from s3object s WHERE (7,8.5,9) = s.nested[1]`,

        getScheduledJob(form).ifPresent(entity -> {
            try {
                scheduledJobService.store(entity);
                saveInfo(messages -> messages.addSuccessCrudCreateCrudTable(GLOBAL));
            } catch (final Exception e) {
                logger.warn("Failed to process a request.", e);
                throwValidationError(messages -> messages.addErrorsCrudFailedToCreateCrudTable(GLOBAL, buildThrowableMessage(e)),

                try {
                    File tempFile = File.createTempFile(prefix, suffix);
                    tempFile.deleteOnExit();
                    return tempFile;
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
        };
        systemHelper.init();
        ComponentUtil.register(systemHelper, "systemHelper");

      fail(message);
    } catch (UnsupportedOperationException expected) {
    }
  }

  private void expectReturnsFalseOrThrows(Target target) {
    String message = Platform.format("retainAll(%s) should return false or throw", target);
    try {
      assertFalse(message, collection.retainAll(target.toRetain));
    } catch (UnsupportedOperationException tolerated) {
    }
  }

    q: Annotated[
        str | None,
        Query(
            alias="item-query",
            title="Query string",
            description="Query string for the items to search in the database that have a good match",
            min_length=3,
            max_length=50,
            pattern="^fixedquery$",
            deprecated=True,
        ),
    ] = None,
):
    results = {"items": [{"item_id": "Foo"}, {"item_id": "Bar"}]}

        final int type = sid.getType();
        if (logger.isDebugEnabled()) {
            try {
                logger.debug("Processing SID: {} {} {}", type, sid, sid.toDisplayString());
            } catch (final Exception e) {
                // ignore
            }
        }
        final Integer id = fessConfig.getAvailableSmbSidType(type);
        if (id != null) {

        final Exception[] exceptionHolder = new Exception[1];

        Thread thread = new Thread(() -> {
            try {
                clientHolder[0] = new CrawlerEngineClient();
            } catch (Exception e) {
                exceptionHolder[0] = e;
            }
        });

        thread.start();
        thread.join();

        assertNull(exceptionHolder[0]);
        assertNotNull(clientHolder[0]);

                return values().asList().get(index + 1);
              });
    } catch (UnsupportedOperationException tolerated) {
    }
    expectUnchanged();
  }

  @MapFeature.Require(absent = SUPPORTS_PUT)
  public void testReplaceAll_unsupportedNoOpFunction() {
    try {
      getMap().replaceAll((K k, V v) -> v);
    } catch (UnsupportedOperationException tolerated) {
    }
    expectUnchanged();
  }

      recordedTasks = tasks;
      recordedTimeout = timeout;
      recordedTimeUnit = unit;
      try {
        return tasks.iterator().next().call();
      } catch (Exception e) {
        throw new ExecutionException(e);
      }
    }

    @Override
    public <T> List<Future<T>> invokeAll(
        Collection<? extends Callable<T>> tasks, long timeout, TimeUnit unit)

     *
     * @see jcifs.CIFSContext#get(java.lang.String)
     */
    @Override
    public SmbResource get(final String url) throws CIFSException {
        try {
            return new SmbFile(url, this);
        } catch (final MalformedURLException e) {
            throw new CIFSException("Invalid URL " + url, e);
        }
    }

    /**
     *
     * {@inheritDoc}
     *