assertTrue(r1.getName().endsWith("/"), "Name should end with '/'");

        assertTrue(itr.hasNext(), "Should have second element ready");
        SmbResource r2 = itr.next();
        assertNotNull(r2, "Second adapted resource must not be null");
        assertTrue(r2.getName().endsWith("/"), "Name should end with '/'");

import static com.google.common.cache.TestingCacheLoaders.identityLoader;
import static com.google.common.truth.Truth.assertThat;
import static java.util.concurrent.TimeUnit.SECONDS;

import com.google.common.cache.LocalCache.LocalLoadingCache;
import com.google.common.cache.LocalCache.Segment;
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.ImmutableSet;

    }

    /**
     * Sets the minimum number of seconds that a response will continue to be fresh for. If the
     * response will be stale when [minFresh] have elapsed, the cached response will not be used and
     * a network request will be made.
     *
     * @param minFresh a non-negative integer. This is stored and transmitted with
     *     [TimeUnit.SECONDS] precision; finer precision will be lost.
     */

    void testJoinWithStringBuilder() {
        StringBuilder sb1 = new StringBuilder("first");
        StringBuilder sb2 = new StringBuilder("second");
        String result = StringUtil.join(",", sb1, sb2);
        assertEquals("first,second", result);
    }

    @Test
    @DisplayName("Should handle StringBuffer as CharSequence")
    void testJoinWithStringBuffer() {

      if (first == null) {
        actionWhenFirstParamIsNull.act();
      }
      if (second == null) {
        actionWhenSecondParamIsNull.act();
      }
    }

    /** Two-arg method with no Nullable params. */
    public void normalNormal(String first, Integer second) {
      reactToNullParameters(first, second);
    }

   * @param second the second array of elements to concatenate
   * @param type the component type of the returned array
   */
  @GwtIncompatible // Array.newInstance(Class, int)
  public static <T extends @Nullable Object> T[] concat(
      T[] first, T[] second, Class<@NonNull T> type) {
    T[] result = newArray(type, first.length + second.length);
    arraycopy(first, 0, result, 0, first.length);

        assertEquals((byte) 0xA1, encoded[0], "First byte of first character");
        assertEquals((byte) 0x00, encoded[1], "Second byte of first character");
        assertEquals((byte) 0xA2, encoded[2], "First byte of second character");
        assertEquals((byte) 0x00, encoded[3], "Second byte of second character");
    }

    @Test
    public void testAsciiEncoding() throws Exception {

                throw new RuntimeException("Operation timed out after 30 seconds");
            }
        };
        ComponentUtil.register(searchEngineClient, "searchEngineClient");

        // Execute the job
        String result = purgeDocJob.execute();

        // Assert error message is in the result
        assertTrue(result.contains("Operation timed out after 30 seconds"));
    }

 * limitations under the License.
 */

package com.google.common.util.concurrent;

import static java.util.concurrent.Executors.newFixedThreadPool;
import static java.util.concurrent.TimeUnit.SECONDS;

import com.google.common.annotations.GwtIncompatible;
import com.google.common.annotations.J2ktIncompatible;
import java.util.ArrayList;
import java.util.Random;
import java.util.concurrent.Callable;

    public int compare(@Nullable String first, @Nullable String second) {
      if (first == second) {
        return 0;
      } else if (first == null) {
        return -1;
      } else if (second == null) {
        return 1;
      } else if (first.length() != second.length()) {
        return first.length() - second.length();
      } else {
        return first.compareTo(second);
      }
    }
  }