"danish_keywords": {
          "type":       "keyword_marker",
          "keywords": ["Hej", "verden", "Søg"]
        },
        "danish_stemmer": {
          "type":       "stemmer",
          "language":   "danish"
        },
        "danish_override": {
          "type":       "stemmer_override",
          "rules": []
        },
        "dutch_stop": {
          "type":       "stop",

errors.crud_failed_to_create_instance = Nie można utworzyć nowych danych.
errors.crud_failed_to_create_crud_table = Nie można utworzyć nowych danych. ({0})
errors.crud_failed_to_update_crud_table=Nie można zaktualizować danych. ({0})
errors.crud_failed_to_delete_crud_table=Nie można usunąć danych. ({0})
errors.crud_could_not_find_crud_table = Nie znaleziono danych {0}.
errors.could_not_find_backup_index=Nie znaleziono indeksu kopii zapasowej.

labels.crawling_info_DataCrawlExecTime=Czas wykonania indeksowania (Magazyn danych)
labels.crawling_info_DataCrawlStartTime=Czas rozpoczęcia indeksowania (Magazyn danych)
labels.crawling_info_DataCrawlEndTime=Czas zakończenia indeksowania (Magazyn danych)
labels.crawling_info_DataIndexExecTime=Czas wykonania indeksowania (Magazyn danych)
labels.crawling_info_DataIndexSize=Rozmiar indeksu (Magazyn danych)
labels.webauth_configuration=Uwierzytelnianie web

   * finite. Call either {@link LinearTransformationBuilder#and} or {@link
   * LinearTransformationBuilder#withSlope} on the returned object to finish building the instance.
   */
  public static LinearTransformationBuilder mapping(double x1, double y1) {
    checkArgument(isFinite(x1) && isFinite(y1));
    return new LinearTransformationBuilder(x1, y1);
  }

  /**

    // the run latch.
    exec.execute(task);
    runLatch.await();
    assertEquals(1, listenerLatch.getCount());
    assertFalse(task.isDone());
    assertFalse(task.isCancelled());

    // Finish the task by unblocking the task latch.  Then wait for the
    // listener to be called by blocking on the listener latch.
    taskLatch.countDown();
    assertEquals(25, task.get().intValue());

    }
    return new ListenableFutureAdapter<>(future, executor);
  }

  /**
   * An adapter to turn a {@link Future} into a {@link ListenableFuture}. This will wait on the
   * future to finish, and when it completes, run the listeners. This implementation will wait on
   * the source future indefinitely, so if the source future never completes, the adapter will never
   * complete either.
   *

    // the run latch.
    exec.execute(task);
    runLatch.await();
    assertEquals(1, listenerLatch.getCount());
    assertFalse(task.isDone());
    assertFalse(task.isCancelled());

    // Finish the task by unblocking the task latch.  Then wait for the
    // listener to be called by blocking on the listener latch.
    taskLatch.countDown();
    assertEquals(25, task.get().intValue());

  }

  /**
   * Returns a future that delegates to this future but will finish early (via a {@link
   * TimeoutException} wrapped in an {@link ExecutionException}) if the specified timeout expires.
   * If the timeout expires, not only will the output future finish, but also the input future
   * ({@code this}) will be cancelled and interrupted.
   *

We welcome pull requests for your language.

### Translations

- [日本語 (Japanese)](docs/ja/README.md)
- [简体中文 (Simplified Chinese)](docs/zh-CN/README.md)
- [Español (Spanish)](docs/es/README.md)
- [Português (Brazilian Portuguese)](docs/pt-BR/README.md)
- [Français (French)](docs/fr/README.md)
- [Deutsch (German)](docs/de/README.md)
- [한국어 (Korean)](docs/ko/README.md)

## Powered By

    boolean lockAcquired = tryLockUninterruptibly(lock, 500, MILLISECONDS);

    assertFalse(lockAcquired);
    assertAtLeastTimePassed(stopwatch, 500);
    assertNotInterrupted();

    // finish locking thread
    lockThread.interrupt();
  }

  public void testTryLockTimeoutNotExceeded() {
    Stopwatch stopwatch = Stopwatch.createStarted();
    Lock lock = new ReentrantLock();