* @param target a primitive {@code short} value
   * @return the least index {@code i} for which {@code array[i] == target}, or {@code -1} if no
   *     such index exists.
   */
  public static int indexOf(short[] array, short target) {
    return indexOf(array, target, 0, array.length);
  }

  // TODO(kevinb): consider making this public

        assertArgumentNotNull("rootDir", rootDir);
        assertArgumentNotNull("handler", handler);

        final File packageDir = getPackageDir(rootDir, rootPackage);
        if (packageDir.exists()) {
            traverseFileSystem(packageDir, rootPackage, handler);
        }
    }

    /**
     * Traverses classes contained in a Jar file.
     * <p>

If it doesn't see an `Authorization` header, or the value doesn't have a `Bearer ` token, it will respond with a 401 status code error (`UNAUTHORIZED`) directly.

You don't even have to check if the token exists to return an error. You can be sure that if your function is executed, it will have a `str` in that token.

You can try it already in the interactive docs:

<img src="/img/tutorial/security/image03.png">

		}

		datas, ok := identityMap[utils.ToStringKey(fieldValues...)]
		if !ok {
			return fmt.Errorf("failed to assign association %#v, make sure foreign fields exists", elem.Interface())
		}

		for _, data := range datas {
			reflectFieldValue := rel.Field.ReflectValueOf(tx.Statement.Context, data)
			if reflectFieldValue.Kind() == reflect.Ptr && reflectFieldValue.IsNil() {

     * Adds a system property to the command list.
     * If the property exists in the system, it uses that value with optional append value.
     * Otherwise, it uses the default value if provided.
     *
     * @param cmdList the command list to add the property to
     * @param name the property name
     * @param defaultValue the default value to use if property doesn't exist
     * @param appendValue the value to append to the property value

     * @return number of keys in memory
     */
    public int getKeyCount() {
        return sessionKeys.size();
    }

    /**
     * Check if a session key exists
     *
     * @param sessionId session identifier
     * @return true if key exists
     */
    public boolean hasSessionKey(String sessionId) {
        checkNotClosed();

        });

        // Verify hash was reset
        Method resetMethod = findMethod(transport.getClass(), "resetPreauthHash");
        if (resetMethod != null) {
            // Verify the reset method exists
            assertNotNull(resetMethod);
        }
    }

    /**
     * Test that getPreauthIntegrityHash returns a defensive copy
     */
    @Test

        assertEquals("11-malformed:-invalid", result[3]);
    }

    @Override
    public void tearDown() throws Exception {
        // Restore original java.version property if it exists
        String originalVersion = System.getProperty("java.version");
        if (originalVersion != null) {
            System.setProperty("java.version", originalVersion);
        }
        super.tearDown();
    }

  public TreeTraverser() {}

  /**
   * Returns a tree traverser that uses the given function to navigate from a node to its children.
   * This is useful if the function instance already exists, or so that you can supply a lambda
   * expressions. If those circumstances don't apply, you probably don't need to use this; subclass
   * {@code TreeTraverser} and implement its {@link #children} method directly.
   *

    return mapEntry(key, value);
  }

  @Override
  protected void expectContents(Collection<Entry<K, V>> expected) {
    // TODO: move this to invariant checks once the appropriate hook exists?
    super.expectContents(expected);
    for (Entry<K, V> entry : expected) {
      assertEquals(
          "Wrong value for key " + entry.getKey(), entry.getValue(), getMap().get(entry.getKey()));
    }
  }