@SuppressWarnings("serial") // No serialization is used in this test
@GwtCompatible
@NullMarked
public class AbstractIteratorTest extends TestCase {

  public void testDefaultBehaviorOfNextAndHasNext() {

    // This sample AbstractIterator returns 0 on the first call, 1 on the
    // second, then signals that it's reached the end of the data
    Iterator<Integer> iter =
        new AbstractIterator<Integer>() {
          private int rep;

                // Return unsorted list to test sorting
                return List.of("Zebra", "Apple", "Banana").stream().sorted().collect(java.util.stream.Collectors.toList());
            }
        };

        List<String> names = testFactory.loadDataStoreNameList();
        assertEquals(3, names.size());
        assertEquals("Apple", names.get(0));
        assertEquals("Banana", names.get(1));

  }

  public void testCopyOf_concurrentlyMutating() {
    List<String> sample = Lists.newArrayList("a", "b", "c");
    for (int delta : new int[] {-1, 0, 1}) {
      for (int i = 0; i < sample.size(); i++) {
        Collection<String> misleading = misleadingSizeCollection(delta);
        List<String> expected = sample.subList(0, i);
        misleading.addAll(expected);

    return Math.sqrt(populationVariance());
  }

  /**
   * Returns the <a href="http://en.wikipedia.org/wiki/Variance#Sample_variance">unbiased sample
   * variance</a> of the values. If this dataset is a sample drawn from a population, this is an
   * unbiased estimator of the population variance of the population. The count must be greater than
   * one.
   *

    for (char base : zeros.toCharArray()) {
      for (int offset = 0; offset < 10; offset++) {
        sb.append((char) (base + offset));
      }
    }
    ALL_DIGITS = sb.toString();
  }

  /** Sample CharMatcher instances for benchmarking. */
  public enum SampleMatcherConfig {
    WHITESPACE(CharMatcher.whitespace(), WHITESPACE_CHARACTERS),
    HASH(CharMatcher.is('#'), "#"),
    ASCII(CharMatcher.ascii(), ASCII_CHARACTERS),

        /** Internet Explorer and Trident-based browsers */
        IE,
        /** Mozilla Firefox browser */
        FIREFOX,
        /** Google Chrome browser */
        CHROME,
        /** Apple Safari browser */
        SAFARI,
        /** Opera browser */
        OPERA,
        /** Other or unrecognized browser types */
        OTHER;
    }

    public void test_entrySet_with_lang_key() {
        Map<String, Object> parentMap = new LinkedHashMap<>();
        DocMap docMap = new DocMap(parentMap);

        docMap.put("zebra", "value1");
        docMap.put("apple", "value2");
        docMap.put("lang", "ja");
        docMap.put("banana", "value3");

        Set<Map.Entry<String, Object>> entrySet = docMap.entrySet();
        assertEquals(4, entrySet.size());

import java.util.Iterator;
import java.util.List;
import java.util.Map.Entry;
import org.jspecify.annotations.NullMarked;
import org.jspecify.annotations.Nullable;

/**
 * A container class for the five sample elements we need for testing.
 *
 * @author Kevin Bourrillion
 */
@GwtCompatible
@NullMarked
public class SampleElements<E extends @Nullable Object> implements Iterable<E> {

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package okhttp3.sample;

import java.io.File;
import java.io.IOException;
import java.util.Collections;
import java.util.LinkedHashSet;
import java.util.Set;
import java.util.concurrent.BlockingQueue;

   *
   * <ul>
   *   <li>The non-private constructor or non-private static factory method with the most parameters
   *       is used to construct the sample instances. In case of tie, the candidate constructors or
   *       factories are tried one after another until one can be used to construct sample
   *       instances.
   *   <li>For the constructor or static factory method used to construct instances, it's checked