users outside your own control), you should not use beta APIs unless you
    [repackage] them. **If your code is a library, we strongly recommend using
    the [Guava Beta Checker] to ensure that you do not use any `@Beta` APIs!**

2.  APIs without `@Beta` will remain binary-compatible for the indefinite
    future. (Previously, we sometimes removed such APIs after a deprecation

   * garbage-collected, even if there are no more instances of FinalizableReferenceQueue itself.
   * The code in FinalizableReferenceQueue goes to considerable trouble to ensure that there are
   * no such references and the tests here check that that trouble has not been in vain.
   *
   * When we reference FinalizableReferenceQueue in this test, we are referencing a class that is

		log_begin_msg "Already running."
		log_end_msg 0
		exit 0
	fi

	# Prepare environment
	mkdir -p "$LOG_DIR" "$DATA_DIR" && chown "$FESS_USER":"$FESS_GROUP" "$LOG_DIR" "$DATA_DIR"

	# Ensure that the PID_DIR exists (it is cleaned at OS startup time)
	if [ -n "$PID_DIR" ] && [ ! -e "$PID_DIR" ]; then
		mkdir -p "$PID_DIR" && chown "$FESS_USER":"$FESS_GROUP" "$PID_DIR"
	fi

                storage.create(BucketInfo.newBuilder(bucket).build());
                logger.info("Created storage bucket: {}", bucket);
            }
        } catch (final Exception e) {
            logger.warn("Failed to ensure bucket exists: {}", bucket, e);
        }
    }

    @Override
    public boolean isAvailable() {
        try {
            return storage.get(bucket) != null;
        } catch (final Exception e) {

import jcifs.internal.util.SMBUtil;
import jcifs.util.Crypto;

/**
 * SMB2/SMB3 message signing digest implementation.
 *
 * This class handles cryptographic signing of SMB2/SMB3 messages to ensure
 * message integrity and authenticity. It supports different signing algorithms
 * used in various SMB2/SMB3 dialect versions.
 *
 * @author mbechler
 */

        applyRule<DependencyRemovalByNameRule>("org.apache.groovy:groovy-ant", setOf("ant-junit"))

        // GCS transitively depends on commons-logging.
        // Ensure jcl-over-slf4j is pulled in when we use GCS so it can conflict.
        applyRule<DependencyAdditionRule>("com.google.apis:google-api-services-storage", "org.slf4j:jcl-over-slf4j")

            testMessage.setExtendedSecurity(false);
            // Method is empty, just ensure no exception
        }

        @Test
        @DisplayName("Should ignore UID setting")
        void testSetUid() {
            testMessage.setUid(123);
            // Method is empty, just ensure no exception
        }
    }

    @Nested
    @DisplayName("Equals and HashCode Tests")

software and other kinds of works, specifically designed to ensure
cooperation with the community in the case of network server software.

  The licenses for most software and other practical works are designed
to take away your freedom to share and change the works.  By contrast,
our General Public Licenses are intended to guarantee your freedom to
share and change all versions of a program--to make sure it remains free
software for all its users.

  api 'gradle.plugin.com.github.jengelman.gradle.plugins:shadow:7.0.0'
  // for our ide tweaking
  api 'gradle.plugin.org.jetbrains.gradle.plugin.idea-ext:gradle-idea-ext:0.7'
  // When upgrading forbidden apis, ensure dependency version is bumped in ThirdPartyPrecommitPlugin as well
  api 'de.thetaphi:forbiddenapis:3.1'
  api 'com.avast.gradle:gradle-docker-compose-plugin:0.14.0'
  api 'org.apache.maven:maven-model:3.6.2'

  public void runTest() throws Exception {
    /*
     * Note that we do not run this test under Android at the moment. For Android testing, see
     * AggregateFutureStateDefaultAtomicHelperTest.
     */

    // First, ensure that our classloaders are initializing the correct helper versions:

    checkHelperVersion(getClass().getClassLoader(), "SafeAtomicHelper");
    checkHelperVersion(NO_ATOMIC_FIELD_UPDATER, "SynchronizedAtomicHelper");