FESS_USER="${packaging.fess.user}"
FESS_GROUP="${packaging.fess.group}"

# Source the default env file
FESS_ENV_FILE="${packaging.env.file}"
if [ -f "$FESS_ENV_FILE" ]; then
    . "$FESS_ENV_FILE"
fi

IS_UPGRADE=false

case "$1" in

    # Debian ####################################################
    configure)

        # If $1=configure and $2 is set, this is an upgrade
        if [ -n $2 ]; then
            IS_UPGRADE=true

    @Override
    public void execute(MavenSession session) {}

    @Override
    public Set<Plugin> getPluginsBoundByDefaultToAllLifecycles(String packaging) {
        Set<Plugin> plugins;

        // NOTE: The upper-case packaging name is intentional, that's a special hinting mode used for certain tests
        if ("JAR".equals(packaging)) {
            plugins = new LinkedHashSet<>();

        assertEquals(1_500L, mock.createTime());
        assertEquals(1_800L, mock.lastModified());
        assertEquals(100L, mock.length());
    }

    @Nested
    @DisplayName("Edge case values")
    class EdgeCases {

        @Test
        @DisplayName("Null name is allowed via mock")
        void nullName() {
            FileEntry mock = mock(FileEntry.class);

   * Adds a number of occurrences of an element to this multiset. Note that if {@code occurrences ==
   * 1}, this method has the identical effect to {@link #add(Object)}. This method is functionally
   * equivalent (except in the case of overflow) to the call {@code
   * addAll(Collections.nCopies(element, occurrences))}, which would presumably perform much more
   * poorly.
   *

		v := strings.ToLower(vs)
		switch v {
		case "true", "false":
			objectLockEnabled = v == "true"
		default:
			writeErrorResponse(ctx, w, errorCodes.ToAPIErr(ErrInvalidRequest), r.URL)
			return
		}
	}

	forceCreate := false
	if vs := r.Header.Get(xhttp.MinIOForceCreate); len(vs) > 0 {
		v := strings.ToLower(vs)
		switch v {
		case "true", "false":
			forceCreate = v == "true"
		default:

            boolean result = validator.determineValid(cron);
            // Test that validation completes without exception
            assertNotNull("Validation should return a boolean result for edge case: " + cron, Boolean.valueOf(result));
        }
    }

    public void test_constructorAndInitialize() {
        assertNotNull(validator);

        // Test initialize method doesn't throw exception

 * the License.
 */

package com.google.common.reflect;

import static com.google.common.base.Preconditions.checkArgument;
import static com.google.common.base.Preconditions.checkNotNull;
import static com.google.common.base.Preconditions.checkState;
import static java.util.Arrays.asList;

import com.google.common.base.Joiner;
import com.google.common.collect.ImmutableMap;

      /*
       * requireNonNull is safe as long as callers pass a nextSibling that (a) has the same key and
       * (b) is present in the multimap. (And they do, except maybe in case of concurrent
       * modification, in which case all bets are off.)
       */
      KeyList<K, V> keyList = requireNonNull(keyToKeyList.get(key));
      keyList.count++;
      node.previous = nextSibling.previous;

	if err != nil {
		c.Fatalf("Unable to attach policy: %v", err)
	}

	cases := []struct {
		tokenType  string
		fullRevoke bool
		selfRevoke bool
	}{
		{"", true, false},        // Case 1
		{"", true, true},         // Case 2
		{"type-1", false, false}, // Case 3
		{"type-2", false, true},  // Case 4
		{"type-2", true, true},   // Case 5 - repeat type 2 to ensure previous revoke does not affect it.
	}

# Bigger Applications - Multiple Files { #bigger-applications-multiple-files }

If you are building an application or a web API, it's rarely the case that you can put everything in a single file.

**FastAPI** provides a convenience tool to structure your application while keeping all the flexibility.

/// info

If you come from Flask, this would be the equivalent of Flask's Blueprints.

///

## An example file structure { #an-example-file-structure }