pkg syscall (freebsd-arm), const SIGSYS Signal
pkg syscall (freebsd-arm), const SIGTHR Signal
pkg syscall (freebsd-arm), const SIGTSTP Signal
pkg syscall (freebsd-arm), const SIGTTIN Signal
pkg syscall (freebsd-arm), const SIGTTOU Signal
pkg syscall (freebsd-arm), const SIGURG Signal
pkg syscall (freebsd-arm), const SIGUSR1 Signal
pkg syscall (freebsd-arm), const SIGUSR2 Signal

  @CheckForNull
  public E lower(E element) {
    return forward.higher(element);
  }

  @Override
  @CheckForNull
  public E floor(E element) {
    return forward.ceiling(element);
  }

  @Override
  @CheckForNull
  public E ceiling(E element) {
    return forward.floor(element);
  }

  @Override
  @CheckForNull
  public E higher(E element) {
    return forward.lower(element);
  }

        if ( ( msg.getFlags2() & SmbConstants.FLAGS2_SECURITY_SIGNATURES ) == 0 ) {
            // signature requirements need to be checked somewhere else
            log.warn("Expected signed response, but is not signed");
            return false;
        }

        update(this.macSigningKey, 0, this.macSigningKey.length);
        int index = offset;
        update(data, index, SmbConstants.SIGNATURE_OFFSET);

    }
  }

  @Test
  fun testBuildIfSupported() {
    val actual = OpenJSSEPlatform.buildIfSupported()
    assertThat(actual).isNotNull()
  }

  private fun enableTls() {
    // Generate a self-signed cert for the server to serve and the client to trust.
    // can't use TlsUtil.localhost with a non OpenJSSE trust manager
    val heldCertificate =
      HeldCertificate.Builder()
        .commonName("localhost")

		ipList       []string
		sortedIPList []string
	}{
		// Default case of two ips one with higher octet moves
		// to the beginning of the list.
		{
			ipList:       []string{"127.0.0.1", "10.0.0.13"},
			sortedIPList: []string{"10.0.0.13", "127.0.0.1"},
		},
		// With multiple types of octet, chooses a higher octet.
		{
			ipList:       []string{"127.0.0.1", "172.0.21.1", "192.168.1.106"},

//     Vendors might change the settings based on the configuration and scale out of the solution (more storage nodes =>
//     higher task limit).
//
//     <S3ConcurrentTaskLimit>
//
//   - Defines how many S3 operations are executed parallel within one Repository Task Slot (and within one backup object

import org.codehaus.mojo.animal_sniffer.IgnoreJRERequirement

object TlsUtil {
  val password = "password".toCharArray()

  private val localhost: HandshakeCertificates by lazy {
    // Generate a self-signed cert for the server to serve and the client to trust.
    val heldCertificate =
      HeldCertificate.Builder()
        .commonName("localhost")
        .addSubjectAlternativeName("localhost")

{!> ../../docs_src/dependencies/tutorial006.py!}
```

////

## Dependências para um grupo de *operações de rota*

Mais a frente, quando você ler sobre como estruturar aplicações maiores ([Bigger Applications - Multiple Files](../../tutorial/bigger-applications.md){.internal-link target=_blank}), possivelmente com múltiplos arquivos, você aprenderá a declarar um único parâmetro `dependencies` para um grupo de *operações de rota*.

## Dependências globais

public class LoadingCacheSingleThreadBenchmark {
  @Param({"1000", "2000"})
  int maximumSize;

  @Param("5000")
  int distinctKeys;

  @Param("4")
  int segments;

  // 1 means uniform likelihood of keys; higher means some keys are more popular
  // tweak this to control hit rate
  @Param("2.5")
  double concentration;

  Random random = new Random();

  LoadingCache<Integer, Integer> cache;

  int max;

## Exemplo

Para um exemplos simples, vamos considerar uma estrutura de arquivos semelhante ao descrito em [Bigger Applications](../tutorial/bigger-applications.md){.internal-link target=_blank} e [Testing](../tutorial/testing.md){.internal-link target=_blank}:

```
.
├── app
│   ├── __init__.py
│   ├── main.py
│   └── test_main.py
```