corsFilter.doFilter(mockRequest, mockResponse, mockFilterChain);

        assertTrue(mockFilterChain.wasDoFilterCalled());
        assertFalse(corsHandlerFactory.wasGetCalled());
    }

    // Test with whitespace-only Origin header
    public void test_doFilter_whitespaceOriginHeader() throws IOException, ServletException {
        mockRequest.setHeader("Origin", "   ");

        assertEquals(emptyMessage, exception.getMessage());
        assertNull(exception.getCause());
    }

    public void test_getMessage_withWhitespaceMessage() {
        // Test constructor with whitespace-only message
        String whitespaceMessage = "   ";
        SsoProcessException exception = new SsoProcessException(whitespaceMessage);

        assertEquals(whitespaceMessage, exception.getMessage());

      }
    }
  }

  /**
   * Reads the first line from a file. The line does not include line-termination characters, but
   * does include other leading and trailing whitespace.
   *
   * @param file the file to read from
   * @param charset the charset used to decode the input stream; see {@link StandardCharsets} for
   *     helpful predefined constants

        item.setNewInput(newSpecialInput);
        assertEquals(newSpecialInput, item.toLineString());
    }

    public void test_whitespaceHandling() {
        // Test with various whitespace scenarios
        ProtwordsItem item1 = new ProtwordsItem(1, "  word  ");
        assertEquals("  word  ", item1.getInput());
        assertEquals("  word  ", item1.toLineString());

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package com.google.common.base;

import static com.google.common.base.CharMatcher.whitespace;
import static org.junit.Assert.assertThrows;

import com.google.common.annotations.GwtCompatible;
import com.google.common.annotations.GwtIncompatible;
import com.google.common.annotations.J2ktIncompatible;

        ScriptEngine retrieved = scriptEngineFactory.getScriptEngine("test-engine.v1");
        assertNotNull(retrieved);
        assertEquals(engine, retrieved);
    }

    // Test add with whitespace in name
    public void test_add_whitespaceInName() {
        TestScriptEngine engine = new TestScriptEngine();
        scriptEngineFactory.add("  test  ", engine);

        while (st.hasMoreElements()) {
            list.add(st.nextElement().toString());
        }
        return list.toArray(new String[list.size()]);
    }

    /**
     * Removes whitespace from the left side of the string.
     *
     * @param text
     *            The text to trim
     * @return The resulting string
     */
    public static final String ltrim(final String text) {

        assertNotNull(result);
        assertTrue(result instanceof MatchAllQueryBuilder);
    }

    public void test_execute_withWhitespaceContext() {
        // Test execute with whitespace query string context
        QueryContext context = new QueryContext("   ", false);
        MatchAllDocsQuery query = new MatchAllDocsQuery();
        float boost = 1.0f;

     */
    doExtensiveTest("testdata/simplifypathnoprefixtests.txt");
  }

  private void doExtensiveTest(String resourceName) throws IOException {
    Splitter splitter = Splitter.on(CharMatcher.whitespace());
    URL url = getClass().getResource(resourceName);
    for (String line : Resources.readLines(url, UTF_8)) {
      Iterator<String> iterator = splitter.split(line).iterator();
      String input = iterator.next();

        // Execute
        String result = pingSearchEngineJob.execute();

        // Assert
        assertEquals("Status of test-cluster is changed to YELLOW.", result);
    }

    // Test with whitespace in notification addresses
    public void test_execute_whitespaceInNotificationAddresses() {
        // Setup mock components
        SearchEngineClient searchEngineClient = new SearchEngineClient() {
            @Override