// Assert
        assertNotNull(table, "DOS_ERROR_CODES must not be null");
        assertTrue(table.length > 0, "DOS_ERROR_CODES must not be empty");
        for (int i = 0; i < table.length; i++) {
            int[] pair = table[i];
            assertNotNull(pair, "row " + i + " must not be null");
            assertEquals(2, pair.length, "row " + i + " must be [dos, ntstatus]");
        }
    }

    @Test
    @DisplayName("Should format error message for file not found")
    void testFileNotFoundError() {
        // Given
        int ntStatus = NtStatus.NT_STATUS_OBJECT_NAME_NOT_FOUND;

        // When
        SmbException exception = new SmbException(ntStatus, false);

        // Then
        assertTrue(exception.getMessage().toLowerCase().contains("not found")

But Facebook login doesn't support OpenID Connect. It has its own flavor of OAuth2.

### OpenID (not "OpenID Connect") { #openid-not-openid-connect }

There was also an "OpenID" specification. That tried to solve the same thing as **OpenID Connect**, but was not based on OAuth2.

So, it was a complete additional system.

It is not very popular or used nowadays.

## OpenAPI { #openapi }

 * change between Java releases.
 *
 * <p><b>Warning:</b> Chunks of data that are put into the {@link Hasher} are not delimited. The
 * resulting {@link HashCode} is dependent only on the bytes inserted, and the order in which they
 * were inserted, not how those bytes were chunked into discrete put() operations. For example, the
 * following three expressions all generate colliding hash codes:
 *
 * {@snippet :

                throws SmbException {
            // Not used within these tests
            throw new SmbException("not used in tests");
        }

        @Override
        public Subject getSubject() {
            return null; // not relevant for renew() behavior
        }

        @Override
        public void refresh() throws CIFSException {

           * collection like ConcurrentHashMap, which sums up several counters that may not be in
           * sync with one another). We accommodate that by resizing as necessary.
           */
          toJoin = Arrays.copyOf(toJoin, expandedCapacity(toJoin.length, toJoin.length + 1));
        }
        toJoin[i++] = toString(part);
      }
      // We might not have seen the expected number of elements, as discussed above.

      // permitted not to throw because it would be a no-op
    }
    expectUnchanged();
  }

  @MapFeature.Require(value = SUPPORTS_PUT, absent = ALLOWS_NULL_KEY_QUERIES)
  public void testReplace_absentNullKeyUnsupported() {
    try {
      getMap().replace(null, v3());
    } catch (NullPointerException tolerated) {
      // permitted not to throw because it would be a no-op
    }

      // permitted not to throw because it would be a no-op
    }
    expectUnchanged();
  }

  @MapFeature.Require(value = SUPPORTS_PUT, absent = ALLOWS_NULL_KEY_QUERIES)
  public void testReplace_absentNullKeyUnsupported() {
    try {
      getMap().replace(null, v3());
    } catch (NullPointerException tolerated) {
      // permitted not to throw because it would be a no-op
    }

    assertFalse("An object should not be equal to null.", collection.equals(null));
  }

  // A collection should essentially never be equal to a non-collection.
  @SuppressWarnings("UndefinedEquals")
  public void testEquals_notACollection() {
    // noinspection EqualsBetweenInconvertibleTypes
    assertFalse(
        "A Collection should never equal an object that is not a Collection.",
        collection.equals("huh?"));

    return backingMap;
  }

  @SuppressWarnings("unchecked") // value could not get in if not a T
  private <T extends B> @Nullable T trustedPut(
      TypeToken<@NonNull T> type, @ParametricNullness T value) {
    return (T) backingMap.put(type, value);
  }

  @SuppressWarnings("unchecked") // value could not get in if not a T
  private <T extends @NonNull B> @Nullable T trustedGet(TypeToken<T> type) {