return packages;
        }

        private static void walkJavaFiles(Path root, String suffix, Consumer<Path> classConsumer) throws IOException {
            if (Files.exists(root) == false) {
                return;
            }
            Files.walk(root)
                .filter(p -> p.toString().endsWith(suffix))
                .map(root::relativize)

```

In this configuration you can see `MINIO_ETCD_ENDPOINTS` points to the etcd backend which manages MinIO's
`config.json` and bucket DNS SRV records. `MINIO_DOMAIN` indicates the domain suffix for the bucket which
will be used to resolve bucket through DNS. For example if you have a bucket such as `mybucket`, the
client can use now `mybucket.domain.com` to directly resolve itself to the right cluster. `MINIO_PUBLIC_IPS`

    // as we cannot call it directly from the test.
    // This requires a package-private or public method in the class under test,
    // or we can just check for the prefix and suffix.
    // For this test, I'll add a helper in the response class to get super.toString()
    // Or, more simply, check the format of the string.
    @Test
    void testToStringFormat() {

        ]
    }


@pytest.mark.parametrize(
    argnames=["grant_type"],
    argvalues=[
        pytest.param("incorrect", id="incorrect value"),
        pytest.param("passwordblah", id="password with suffix"),
        pytest.param("blahpassword", id="password with prefix"),
    ],
)
def test_strict_login_incorrect_grant_type(grant_type: str):
    response = client.post(
        "/login",

        ]
    }


@pytest.mark.parametrize(
    argnames=["grant_type"],
    argvalues=[
        pytest.param("incorrect", id="incorrect value"),
        pytest.param("passwordblah", id="password with suffix"),
        pytest.param("blahpassword", id="password with prefix"),
    ],
)
def test_strict_login_incorrect_grant_type(grant_type: str):
    response = client.post(
        "/login",

package event

import (
	"reflect"
	"testing"
)

func TestNewPattern(t *testing.T) {
	testCases := []struct {
		prefix         string
		suffix         string
		expectedResult string
	}{
		{"", "", ""},
		{"*", "", "*"},
		{"", "*", "*"},
		{"images/", "", "images/*"},
		{"images/*", "", "images/*"},
		{"", "jpg", "*jpg"},
		{"", "*jpg", "*jpg"},

        fragment = new ViewHelper.TextFragment("prefix", "start", "end", "suffix");
        urlString = fragment.toURLString();
        assertTrue(urlString.contains("prefix"));
        assertTrue(urlString.contains("start"));
        assertTrue(urlString.contains("end"));
        assertTrue(urlString.contains("suffix"));
    }

    @Test
    public void test_ActionHook() {

                super.parseProjectProperties(propFile.toPath());
            }

            @Override
            public File createTempFile(String prefix, String suffix) {
                try {
                    File tempFile = File.createTempFile(prefix, suffix);
                    tempFile.deleteOnExit();
                    return tempFile;
                } catch (IOException e) {
                    throw new RuntimeException(e);

		if start < 0 {
			return 0, 0, errors.New("ScanRange: Start after EOF")
		}
		return start, -1, nil
	}
	if s.Start == nil {
		// Suffix length
		end := int64(*s.End)
		if end < 0 {
			return 0, 0, errors.New("ScanRange: End bigger than file")
		}
		// Suffix length
		return -end, -1, nil
	}
	start = int64(*s.Start)
	end := int64(*s.End)
	return start, end - start + 1, nil
}

        SmbFilenameFilter filter = (dir, n) -> n != null && n.toLowerCase().endsWith(".txt");

        boolean result = filter.accept(mockDir, name);

        assertEquals(expected, result, "Filter should evaluate .txt suffix correctly");
        verifyNoInteractions(mockDir);
    }

    /**
     * Invalid/null inputs: ensure filters can handle null name and dir.
     */
    @ParameterizedTest