Red<Integer> redInteger = new Red<Integer>() {};
    assertEquals(String.class, redString.getClassDirect());
    assertEquals(Integer.class, redInteger.getClassDirect());

    Red<String>.Yellow<Integer> yellowInteger = redString.new Yellow<Integer>(redInteger) {};
    assertEquals(Integer.class, yellowInteger.getClassA());
    assertEquals(Integer.class, yellowInteger.getClassB());

    Red<Integer> redInteger = new Red<Integer>() {};
    assertEquals(String.class, redString.getClassDirect());
    assertEquals(Integer.class, redInteger.getClassDirect());

    Red<String>.Yellow<Integer> yellowInteger = redString.new Yellow<Integer>(redInteger) {};
    assertEquals(Integer.class, yellowInteger.getClassA());
    assertEquals(Integer.class, yellowInteger.getClassB());

        // Boosters should be executed in priority order (3, 2, 1)
        List<Integer> executionOrder = PriorityTrackingBooster.getExecutionOrder();
        assertEquals(3, executionOrder.size());
        assertEquals(Integer.valueOf(3), executionOrder.get(0));
        assertEquals(Integer.valueOf(2), executionOrder.get(1));
        assertEquals(Integer.valueOf(1), executionOrder.get(2));
    }

    ImmutableList<Integer>[] array =
        (ImmutableList<Integer>[]) new ImmutableList<?>[] {ImmutableList.of(1)};
    TypeToken<ImmutableList<Integer>[]> type = new TypeToken<ImmutableList<Integer>[]>() {};
    ImmutableTypeToInstanceMap<Iterable<?>[]> map =
        ImmutableTypeToInstanceMap.<Iterable<?>[]>builder().put(type, array).build();
    assertEquals(1, map.size());

    @Override
    protected SortedSet<Integer> create(Integer[] elements) {
      return checkedCreate(nullCheckedTreeSet(elements));
    }
  }

  public static class ContiguousSetHeadsetGenerator extends AbstractContiguousSetGenerator {
    @Override
    protected SortedSet<Integer> create(Integer[] elements) {
      SortedSet<Integer> set = nullCheckedTreeSet(elements);

        assertEquals("Response content", response.getContent());
        assertEquals("stop", response.getFinishReason());
        assertEquals(Integer.valueOf(100), response.getPromptTokens());
        assertEquals(Integer.valueOf(50), response.getCompletionTokens());
        assertEquals(Integer.valueOf(150), response.getTotalTokens());
        assertEquals("gpt-4", response.getModel());
    }

    @Test
    public void test_setContent() {

      }
    }
  }

  @J2ktIncompatible
  @GwtIncompatible // used only in GwtIncompatible tests
  private static Function<Integer, Integer> newOneTimeExceptionThrower() {
    return new Function<Integer, Integer>() {
      int calls = 0;

      @Override
      public Integer apply(Integer from) {
        if (++calls > 1) {
          fail();
        }
        throw new SomeUncheckedException();
      }
    };

      }
    }
  }

  @J2ktIncompatible
  @GwtIncompatible // used only in GwtIncompatible tests
  private static Function<Integer, Integer> newOneTimeExceptionThrower() {
    return new Function<Integer, Integer>() {
      int calls = 0;

      @Override
      public Integer apply(Integer from) {
        if (++calls > 1) {
          fail();
        }
        throw new SomeUncheckedException();
      }
    };

                    type: integer
                    format: int64
                    example: 0
                  page_size:
                    type: integer
                    example: 20
                  page_number:
                    type: integer
                    example: 1
                  record_count:
                    type: integer
                    format: int64

                "loc": ["query", "q", 0],
                "msg": "Input should be a valid integer, unable to parse string as an integer",
                "input": "five",
            },
            {
                "type": "int_parsing",
                "loc": ["query", "q", 1],
                "msg": "Input should be a valid integer, unable to parse string as an integer",
                "input": "six",
            },
        ]
    }