Klaus Post <******@****.***> 1759093161 +0200

Klaus Post <******@****.***> 1759093161 +0200

                            successCount.incrementAndGet();
                        } catch (Exception e) {
                            failureCount.incrementAndGet();
                        }
                    }
                } finally {
                    latch.countDown();
                }
            });
        }

        assertTrue(latch.await(10, TimeUnit.SECONDS), "Concurrent operations should complete");

Quoc Truong <******@****.***> 1727209746 -0700

                            } catch (GeneralSecurityException e) {
                                // Ignore in concurrent test
                            }
                        }
                    }
                } finally {
                    latch.countDown();
                }
            });
        }

        assertTrue(latch.await(10, TimeUnit.SECONDS), "Concurrent ops should complete");

        assertFalse(pattern.match("/exclude/path"));

        // Should not match non-included path
        assertFalse(pattern.match("/other/path"));
    }

    @Test
    public void test_labelTypePattern_match_onlyIncluded() {
        LabelTypePattern pattern = new LabelTypePattern("test", "/test.*", null);

        // Should match included path
        assertTrue(pattern.match("/test/path"));

## Batch Jobs via Commandline
[mc](http://github.com/minio/mc) provides 'mc batch' command to create, start and manage submitted jobs.

```
NAME:
  mc batch - manage batch jobs

USAGE:
  mc batch COMMAND [COMMAND FLAGS | -h] [ARGUMENTS...]

COMMANDS:
  generate  generate a new batch job definition
  start     start a new batch job

  @Test
  fun cancelImmediatelyAfterEnqueue() {
    server.enqueue(MockResponse())
    val latch = CountDownLatch(1)
    client =
      client
        .newBuilder()
        .addNetworkInterceptor(
          Interceptor { chain: Interceptor.Chain ->
            try {
              latch.await()
            } catch (e: InterruptedException) {
              throw AssertionError(e)
            }

            }
        };

        CountDownLatch latch = new CountDownLatch(1);

        Deferred<SuggestIndexResponse>.Promise promise = suggester.indexer().indexFromQueryLog(reader, 10, 0);
        promise.then(response -> latch.countDown()).error(error -> latch.countDown());

        assertTrue("Should complete within timeout", latch.await(ASYNC_TIMEOUT_SECONDS, TimeUnit.SECONDS));

            try {
                Thread.sleep(100);
            } catch (InterruptedException ignore) {}
            deferred.resolve(new SuggestResponse("", 0, Collections.emptyList(), 0, null));
        });
        th.start();

        final CountDownLatch latch = new CountDownLatch(1);
        deferred.promise().then(response -> latch.countDown());
        assertTrue(latch.await(5, TimeUnit.SECONDS));
    }

    @Test