assertEquals(d1, d2);

        // Different type -> false
        assertFalse(a.equals("not-an-auth"));
    }

    @Test
    @DisplayName("isAnonymous: depends on subject presence and super")
    void isAnonymous_behaviour() {
        Kerb5Authenticator anon = new Kerb5Authenticator((Subject) null);
        assertTrue(anon.isAnonymous(), "Null subject with default super should be anonymous");

        int access = accessCaptor.getValue();
        boolean hasReadData = (access & SmbConstants.FILE_READ_DATA) != 0;
        assertEquals(alsoRead, hasReadData, "FILE_READ_DATA flag presence should match alsoRead");
    }

    @Test
    @DisplayName("openCopyTargetFile retries after removing READONLY and succeeds")
    void openCopyTargetFile_retryOnReadonly_thenSuccess() throws Exception {

 * inputs' {@link Comparable#compareTo compareTo} and {@link Comparator#compare compare} methods as
 * soon as one of them returns a nonzero result. This optimization is typically important only in
 * the presence of expensive {@code compareTo} and {@code compare} implementations.
 *
 * <p>See the Guava User Guide article on <a href=
 * "https://github.com/google/guava/wiki/CommonObjectUtilitiesExplained#comparecompareto">{@code

   *
   * <p>Note that the fail-fast behavior of an iterator cannot be guaranteed as it is, generally
   * speaking, impossible to make any hard guarantees in the presence of unsynchronized concurrent
   * modification. Fail-fast iterators throw {@code ConcurrentModificationException} on a
   * best-effort basis. Therefore, it would be wrong to write a program that depended on this

  /**
   * Adds a single occurrence of the specified element to this multiset.
   *
   * <p>This method refines {@link Collection#add}, which only <i>ensures</i> the presence of the
   * element, to further specify that a successful call must always increment the count of the
   * element, and the overall size of the collection, by one.
   *

  /**
   * Adds a single occurrence of the specified element to this multiset.
   *
   * <p>This method refines {@link Collection#add}, which only <i>ensures</i> the presence of the
   * element, to further specify that a successful call must always increment the count of the
   * element, and the overall size of the collection, by one.
   *

   * methods as implementations of normal converters do?
   *
   * But no matter what we do, it's worth remembering that the resulting code is going to be unsound
   * in the presence of LegacyConverter, at least in the case of users who view the converter as a
   * Function<A, B> or who call convertAll (and for any checkers that apply @PolyNull-like semantics

errors.property_type_double={0} è un numero double.
errors.property_type_date={0} è una data.

errors.storage_file_upload_failure=Caricamento di {0} fallito.
errors.storage_file_not_found=Il file di destinazione non è presente nell'archivio.
errors.storage_file_download_failure=Download di {0} fallito.
errors.storage_access_error=Errore di accesso all'archivio: {0}
errors.storage_no_upload_file=Specificare un file da caricare.