});

        // Note: here, type decides is artifact added to "build path" (for example during resolution)
        // and "build path" is intermediate data that is used to create actual Java classpath/modulepath
        // but to create those, proper filtering should happen via Type properties.
    }

    @Override
    public void addHandlers(Map<String, ArtifactHandler> handlers) {

            @Override
            public void doFilter(ServletRequest req, ServletResponse res) throws IOException, ServletException {
                chainCalled.set(true);
            }
        };

        // Create mock WebApiManager
        WebApiManager webApiManager = new WebApiManager() {
            @Override
            public boolean matches(HttpServletRequest req) {
                return true;
            }

            testHashAlgos = new int[] { PreauthIntegrityNegotiateContext.HASH_ALGO_SHA512 };
        }

        @Test
        @DisplayName("Should create context with constructor parameters")
        void testConstructorWithParameters() {
            // Act
            context = new PreauthIntegrityNegotiateContext(mockConfig, testHashAlgos, testSalt);

            // Assert

import org.codelibs.fess.crawler.transformer.impl.FileTransformer;

public class BasicCrawlerExample {
    public static void main(String[] args) throws Exception {
        // Create crawler container
        StandardCrawlerContainer container = new StandardCrawlerContainer();
        
        // Configure basic components
        container.singleton("crawler", Crawler.class)

app = FastAPI()

security = HTTPBasic(auto_error=False)


@app.get("/users/me")
def read_current_user(credentials: HTTPBasicCredentials | None = Security(security)):
    if credentials is None:
        return {"msg": "Create an account first"}
    return {"username": credentials.username, "password": credentials.password}


client = TestClient(app)


def test_security_http_basic():

    }

    /**
     * Test decode with valid single AvPair followed by EOL
     */
    @Test
    @DisplayName("Decode single AvPair with EOL")
    void testDecodeSinglePair() throws CIFSException {
        // Create test data: AvFlags with value 0x12345678 + EOL
        byte[] flagData = new byte[4];
        SMBUtil.writeInt4(0x12345678, flagData, 0);
        byte[] avPairData = createAvPairData(AvPair.MsvAvFlags, flagData);

   * Returns a new {@code MutableClassToInstanceMap} instance backed by a {@link HashMap} using the
   * default initial capacity and load factor.
   */
  public static <B extends @Nullable Object> MutableClassToInstanceMap<B> create() {
    return new MutableClassToInstanceMap<>(new HashMap<Class<? extends @NonNull B>, B>());
  }

  /**
   * Returns a new {@code MutableClassToInstanceMap} instance backed by a given empty {@code

                // create it if necessary
                this.openFunction = OPEN_FN_TRUNC | OPEN_FN_CREATE;
            } else {
                this.openFunction = OPEN_FN_TRUNC;
            }
        } else // don't truncate the file
        if ((flags & SmbConstants.O_CREAT) == SmbConstants.O_CREAT) {
            // create it if necessary

          return (result < 0) ? LESS : (result > 0) ? GREATER : ACTIVE;
        }

        @Override
        public int result() {
          return 0;
        }
      };

  private static final ComparisonChain LESS = new InactiveComparisonChain(-1);

  private static final ComparisonChain GREATER = new InactiveComparisonChain(1);

touch /tmp/data/mpartobj
shred -s 500M /tmp/data/mpartobj
echo "done"

# Add replication site
./mc admin replicate add minio1 minio2 --insecure
# sleep for replication to complete
sleep 30

# Create bucket in source cluster
echo "Create bucket in source MinIO instance"
./mc mb minio1/test-bucket --insecure

# Load objects to source site with checksum header
echo "Loading objects to source MinIO instance"