import java.util.Arrays;
import java.util.List;
import java.util.Set;
import junit.framework.Test;
import junit.framework.TestCase;
import junit.framework.TestSuite;
import org.jspecify.annotations.NullUnmarked;

/**
 * Tests for CompactLinkedHashSet.
 *
 * @author Dimitris Andreou
 */
@GwtIncompatible // java.util.Arrays#copyOf(Object[], int), java.lang.reflect.Array
@NullUnmarked

import org.junit.jupiter.api.Nested;
import org.junit.jupiter.api.Test;
import org.mockito.Mockito;

/**
 * Tests for {@link WinError} interface constants and static arrays.
 * The interface has no instance methods, so the tests focus on
 * value correctness and array integrity.  A tiny Mockito example
 * demonstrates that the interface can be mocked if another class
 * depends on it.
 */
public class WinErrorTest {

    @Nested

    String[] array = Iterators.toArray(iterator, String.class);
    assertThat(array).isEmpty();
  }

  @GwtIncompatible // Iterators.toArray(Iterator, Class)
  public void testToArraySingleton() {
    Iterator<String> iterator = singletonList("a").iterator();
    String[] array = Iterators.toArray(iterator, String.class);
    assertThat(array).isEqualTo(new String[] {"a"});
  }

    assertThat(Floats.concat(ARRAY1)).isEqualTo(ARRAY1);
    assertThat(Floats.concat(ARRAY1)).isNotSameInstanceAs(ARRAY1);
    assertThat(Floats.concat(EMPTY, ARRAY1, EMPTY)).isEqualTo(ARRAY1);
    assertThat(Floats.concat(ARRAY1, ARRAY1, ARRAY1)).isEqualTo(new float[] {1.0f, 1.0f, 1.0f});
    assertThat(Floats.concat(ARRAY1, ARRAY234)).isEqualTo(new float[] {1.0f, 2.0f, 3.0f, 4.0f});
  }

    assertThat(Floats.concat(ARRAY1)).isEqualTo(ARRAY1);
    assertThat(Floats.concat(ARRAY1)).isNotSameInstanceAs(ARRAY1);
    assertThat(Floats.concat(EMPTY, ARRAY1, EMPTY)).isEqualTo(ARRAY1);
    assertThat(Floats.concat(ARRAY1, ARRAY1, ARRAY1)).isEqualTo(new float[] {1.0f, 1.0f, 1.0f});
    assertThat(Floats.concat(ARRAY1, ARRAY234)).isEqualTo(new float[] {1.0f, 2.0f, 3.0f, 4.0f});
  }

  public void testCombinationsExhaustively_startingFromArbitrary() {
    Ordering<Object> arbitrary = Ordering.arbitrary();
    Object[] array = {1, "foo", new Object()};

    // There's no way to tell what the order should be except empirically
    sort(array, arbitrary);
    testExhaustively(arbitrary, array);
  }

  /**
   * Requires at least 3 elements in {@code strictlyOrderedElements} in order to test the varargs

  public void testCombinationsExhaustively_startingFromArbitrary() {
    Ordering<Object> arbitrary = Ordering.arbitrary();
    Object[] array = {1, "foo", new Object()};

    // There's no way to tell what the order should be except empirically
    sort(array, arbitrary);
    testExhaustively(arbitrary, array);
  }

  /**
   * Requires at least 3 elements in {@code strictlyOrderedElements} in order to test the varargs

    assertThat(Ints.concat(ARRAY1)).isEqualTo(ARRAY1);
    assertThat(Ints.concat(ARRAY1)).isNotSameInstanceAs(ARRAY1);
    assertThat(Ints.concat(EMPTY, ARRAY1, EMPTY)).isEqualTo(ARRAY1);
    assertThat(Ints.concat(ARRAY1, ARRAY1, ARRAY1))
        .isEqualTo(new int[] {(int) 1, (int) 1, (int) 1});
    assertThat(Ints.concat(ARRAY1, ARRAY234))

        // Initially not deleted
        assertFalse(item.isDeleted());

        // Set newInputs to empty array and newOutput
        item.setNewInputs(new String[] {});
        item.setNewOutput("output");
        assertTrue(item.isDeleted());

        // Set newInputs to non-empty array - not deleted
        item.setNewInputs(new String[] { "something" });
        assertFalse(item.isDeleted());
    }

  void setUp() throws Exception {
    Random rng = new Random();
    for (int i = 0; i < 0x100; i++) {
      Integer[] array = new Integer[n];
      for (int j = 0; j < n; j++) {
        array[j] = rng.nextInt();
      }
      inputArrays[i] = array;
    }
  }

  @Benchmark
  int arraysSortNoComparator(int reps) {
    int tmp = 0;
    for (int i = 0; i < reps; i++) {
      Integer[] copy = inputArrays[i & 0xFF].clone();