* to the methods of the delegate. For example, overriding {@link #add} alone <b>will not</b> change
 * the behaviour of {@link #offer} which can lead to unexpected behaviour. In this case, you should
 * override {@code offer} as well, either providing your own implementation, or delegating to the
 * provided {@code standardOffer} method.
 *

        @ParameterizedTest
        @MethodSource("flagsProvider")
        void verifiesCreateDisposition(int flags, int expected) {
            SmbComNTCreateAndX req = createRequest(flags, 0);
            // Use reflection to read the private field createDisposition
            int actual = (int) getPrivateField(req, "createDisposition");
            assertEquals(expected, actual, "createDisposition should match");
        }
    }

    @Test

                .named("ImmutableDoubleArray.asList"),
            ListTestSuiteBuilder.using(new ImmutableDoubleArrayHeadSubListAsListGenerator())
                .named("ImmutableDoubleArray.asList, head subList"),
            ListTestSuiteBuilder.using(new ImmutableDoubleArrayTailSubListAsListGenerator())
                .named("ImmutableDoubleArray.asList, tail subList"),

    checkNotNull(str);
    return (format == this) ? str : convert(format, str);
  }

  /** Enum values can override for performance reasons. */
  String convert(CaseFormat format, String s) {
    // deal with camel conversion
    StringBuilder out = null;
    int i = 0;
    int j = -1;
    while ((j = wordBoundary.indexIn(s, ++j)) != -1) {
      if (i == 0) {
        // include some extra space for separators

    public Artifact find(Artifact artifact) {
        File artifactFile = new File(getBasedir(), pathOf(artifact));

        // We need to set the file here or the resolver will fail with an NPE, not fully equipped to deal
        // with multiple local repository implementations yet.
        artifact.setFile(artifactFile);

        if (artifactFile.exists()) {
            artifact.setResolved(true);
        }

            }
        } else if (metadataFile.exists()) {
            try (InputStream input = Files.newInputStream(metadataFile.toPath())) {
                metadata = new Metadata(new MetadataStaxReader().read(input, false));
            }
        }

        boolean changed;

        // If file could not be found or was not valid, start from scratch
        if (metadata == null) {
            metadata = this.metadata;

    void testSetFlagFalse() {
        msg.setFlag(0x4, true);
        msg.setFlag(0x4, false);
        assertFalse(msg.getFlag(0x4), "Bit should be cleared after setFlag(false)");
    }

    // ---------------- Static read tests -----------------
    @Test
    @DisplayName("readULong correctly interprets little endian")
    void testReadULong() {
        byte[] a = new byte[] { (byte) 0x01, (byte) 0x02, (byte) 0x03, (byte) 0x04 };

import java.util.Map.Entry;
import java.util.Set;
import java.util.concurrent.ExecutionException;
import junit.framework.TestCase;
import org.jspecify.annotations.NullUnmarked;

/**
 * {@link LoadingCache} tests that deal with empty caches.
 *
 * @author mike nonemacher
 */

@NullUnmarked
public class EmptyCachesTest extends TestCase {

  public void testEmpty() {
    for (LoadingCache<Object, Object> cache : caches()) {

 * the methods of the delegate. For example, overriding {@link #add(Object, int)} alone <b>will
 * not</b> change the behavior of {@link #add(Object)}, which can lead to unexpected behavior. In
 * this case, you should override {@code add(Object)} as well, either providing your own
 * implementation, or delegating to the provided {@code standardAdd} method.
 *

	<scm>
		<connection>scm:git:******@****.***:codelibs/jcifs.git</connection>
		<developerConnection>scm:git:******@****.***:codelibs/jcifs.git</developerConnection>
		<url>https://github.com/codelibs/jcifs</url>
	  <tag>HEAD</tag>
  </scm>
	<properties>
		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
		<maven.build.timestamp.format>yyyyMMddHHmm</maven.build.timestamp.format>