queryContext.addQuery(boolQuery -> buildRoleQuery(roleSet, boolQuery));
            }
        }
    }

    /**
     * Builds role-based query filters using the provided role set.
     * This method adds should clauses for allowed roles and must-not clauses for denied roles.
     *
     * @param roleSet the set of roles to use for filtering

// along with this program.  If not, see <http://www.gnu.org/licenses/>.

package lifecycle

import (
	"encoding/xml"
	"time"
)

var (
	errLifecycleInvalidDate         = Errorf("Date must be provided in ISO 8601 format")
	errLifecycleInvalidDays         = Errorf("Days must be positive integer when used with Expiration")

            return this;
        }

        /**
         * Sets the nature of repositories to query when resolving the version range.
         * If {@code null} is provided, defaults to {@link Nature#RELEASE_OR_SNAPSHOT}.
         *
         * @param nature the repository nature, or {@code null} to use the default
         * @return this builder, never {@code null}
         */

        if (pluginArtifact == null) {
            pluginArtifact = toArtifact(plugin, session);
        }

        DependencyFilter collectionFilter = new ScopeDependencyFilter("provided", "test");
        DependencyFilter resolutionFilter = AndDependencyFilter.newInstance(collectionFilter, dependencyFilter);

        DependencyNode node;

        try {

            assertTrue(strategy.isApplicable(context), "Strategy should be applicable when --all is specified");
        }

        @Test
        @DisplayName("should be applicable by default when no specific options provided")
        void shouldBeApplicableByDefaultWhenNoSpecificOptions() {
            UpgradeOptions options = createDefaultOptions();

            UpgradeContext context = createMockContext(options);

        chain.addConverter(new KatakanaToAlphabetConverter());
        return chain;
    }

    /**
     * Creates a default normalizer using the provided client and suggest settings.
     * The normalizer chain includes an AnalyzerNormalizer.
     *
     * @param client the client to be used for creating the normalizer

        // When
        Type1Message type1 = new Type1Message(mockContext, flags, null, null);

        // Then
        // Note: Constructor sets default flags OR'd with provided flags
        assertTrue((type1.getFlags() & flags) != 0);
        // Note: getType() method does not exist in Type1Message
    }

    @Test
    @DisplayName("Should create Type 1 message with domain and workstation")

        assertTrue(type1Token.length > 0);

        // Decode the token to verify its properties
        Type1Message type1Message = new Type1Message(type1Token);
        // Type1Message ORs default flags with provided flags; ensure expected bits are present
        assertTrue((type1Message.getFlags() & context.ntlmsspFlags) == context.ntlmsspFlags);
        assertEquals(domain, type1Message.getSuppliedDomain());
    }

    @Test

	"hash/crc32"
	"hash/crc64"
	"math/bits"
)

// AddPart will merge a part checksum into the current,
// as if the content of each was appended.
// The size of the content that produced the second checksum must be provided.
// Not all checksum types can be merged, use the CanMerge method to check.
// Checksum types must match.
func (c *Checksum) AddPart(other Checksum, size int64) error {
	if !other.Type.CanMerge() {

 * server. Rather than represent each with it's own <code>Exception</code>
 * class, this class represents all of them. For many of the popular
 * error codes, constants and text messages like "The device is not ready"
 * are provided.
 * <p>
 * The jCIFS client maps DOS error codes to NTSTATUS codes. This means that
 * the user may receive a different error from a legacy server than that of