throwValidationErrorApi(messages -> messages.addErrorsCrudFailedToCreateInstance(GLOBAL));
            return null;
        }).orElseGet(() -> {
            throwValidationErrorApi(messages -> messages.addErrorsCrudFailedToCreateInstance(GLOBAL));
            return null;
        });
        stopwordsService.store(body.dictId, entity);
        return asJson(

  private static final Iterable<@Nullable Integer> iterableNull = Arrays.asList((Integer) null);
  private static final Iterable<@Nullable Integer> iterableNullNull =
      Arrays.asList((Integer) null, null);
  private static final Iterable<@Nullable Integer> iterableNull1 = Arrays.asList(null, 1);
  private static final Iterable<@Nullable Integer> iterable1Null = Arrays.asList(1, null);

                    return auth.logout(null, logoutRequestParams, true);
                } catch (final Exception e) {
                    logger.warn("Failed to logout from IdP: {}", samlUser, e);
                }
                return null;
            }).orElse(null);
        }
        return null;
    }

    @Override

        existNextPage = false;
        pageSize = getDefaultPageSize();
        currentPageNumber = getDefaultCurrentPageNumber();

        id = null;
        jobName = null;
        jobStatus = null;
        target = null;
        scriptType = null;
        startTime = null;

    }

    /**
     * Gets the default current page number.
     *
     * @return the default current page number
     */

        if (this.compressionAlgorithms == null) {
            return false;
        }
        for (int algo : this.compressionAlgorithms) {
            if (algo == algorithm) {
                return true;
            }
        }
        return false;
    }

    @Override
    public int encode(byte[] dst, int dstIndex) {
        if (this.compressionAlgorithms == null) {
            return 0;
        }

/**
 * @author shinsuke
 * @author kaorufuzita
 */
public class TextUtilTest extends PlainTestCase {

    public void test_getContent() {
        assertEquals("", normalizeText((String) null, 100, -1, -1, false));
        assertEquals("", normalizeText("", 100, -1, -1, false));
        assertEquals("", normalizeText(" ", 100, -1, -1, false));
        assertEquals("", normalizeText("  ", 100, -1, -1, false));

            assertNull(exception.getMessage());
        });
    }

    @Test
    @DisplayName("Should handle null cause gracefully")
    void testNullCause() {
        // When/Then
        assertDoesNotThrow(() -> {
            RuntimeCIFSException exception = new RuntimeCIFSException((Throwable) null);
            assertNull(exception.getCause());
        });

      if (conscrypt != null) {
        return conscrypt
      }
    }

    if (isBouncyCastlePreferred) {
      val bc = BouncyCastlePlatform.buildIfSupported()

      if (bc != null) {
        return bc
      }
    }

    if (isOpenJSSEPreferred) {
      val openJSSE = OpenJSSEPlatform.buildIfSupported()

      if (openJSSE != null) {
        return openJSSE
      }
    }

    fakeTicker.advance(2, MILLISECONDS);
    assertEquals(null, cache.getIfPresent(10));
    assertEquals(null, cache.getIfPresent(20));
    assertEquals(null, cache.getIfPresent(4));

    cache.put(10, 20);
    assertEquals(Integer.valueOf(20), cache.getIfPresent(10));

    fakeTicker.advance(1000, MILLISECONDS);
    assertEquals(null, cache.getIfPresent(10));
  }

    // Check cache. We use == on purpose because it's cheaper and a cache miss is ok.
    if (entry != null && entry.getKey() == key) {
      return entry.getValue();
    }
    return null;
  }

  void clearCache() {
    cacheEntry = null;
  }