*
     * @param ctype2
     *            The array of character types to set up.
     */
    protected static void setup(final byte[] ctype2) {
        wordChars(ctype2, 'a', 'z');
        wordChars(ctype2, 'A', 'Z');
        wordChars(ctype2, '0', '9');
        wordChar(ctype2, '@');
        wordChar(ctype2, '|');
        wordChar(ctype2, '_');
        wordChar(ctype2, '?');
        wordChar(ctype2, '>');

        scriptEngineFactory.add("type1", engine1);
        scriptEngineFactory.add("type2", engine2);

        // Execute with first engine
        Object result1 = scriptExecutor.execute("type1", "script for engine1");
        assertEquals("engine1:processed: script for engine1", result1);

        // Execute with second engine
        Object result2 = scriptExecutor.execute("type2", "script for engine2");

        CURRENT = JAVA6;
      }
    }

    abstract Type newArrayType(Type componentType);

    abstract Type usedInGenericType(Type type);

    final ImmutableList<Type> usedInGenericType(Type[] types) {
      ImmutableList.Builder<Type> builder = ImmutableList.builder();
      for (Type type : types) {
        builder.add(usedInGenericType(type));
      }
      return builder.build();
    }

    assertThat(buffer.readByteString()).isEqualTo("A20743054A6F6E6573".decodeHex())
  }

  @Test fun `decode implicit tagged implicit prefixed type`() {
    // Type1 ::= VisibleString
    // Type2 ::= [APPLICATION 3] IMPLICIT Type1
    // Type3 ::= [2] Type2
    // Type4 ::= [APPLICATION 7] IMPLICIT Type3
    val buffer =
      Buffer()
        .write("670743054A6F6E6573".decodeHex())

    val derReader = DerReader(buffer)

        assertEquals("Type1", exception1.getType());
        assertEquals("Message1", exception1.getMessage());
        assertEquals("Type2", exception2.getType());
        assertEquals("Message2", exception2.getMessage());

        assertNotSame(exception1, exception2);
    }

    @Test
    public void test_serialVersionUID() {
        // Test that serialVersionUID is properly defined

# ADR-0003 - Avoid introducing Groovy types to public API

## Status

- ACCEPTED on 2024-01-12

## Context

Gradle's public API requires equal access from all JVM-based languages.
Kotlin, Groovy, Java, and other JVM-based languages should be able to use the Gradle API without relying on another language's standard library.

Historically, Gradle has shipped with some Groovy types in very prominent APIs.

                            final Map<String, String> indexObj = dataObj.get("index");
                            if (indexObj != null) {
                                if (indexObj.containsKey("_type")) {
                                    indexObj.remove("_type");
                                }
                                final String index = indexObj.get("_index");
                                if (index != null) {

        assertEquals(type1, type2);

        Map<String, Object> source1 = event.toSource();
        Map<String, Object> source2 = event.toSource();
        assertSame(source1, source2);
    }

    // Test edge cases for version numbers
    @Test
    public void test_versionNumberEdgeCases() {
        TestSearchLogEvent event = new TestSearchLogEvent("id", 0L, "type");

        // Test minimum value

  }

  private static class TypeA {}

  private interface TypeB {}

  private static class HasBoth extends TypeA implements TypeB {}

  @GwtIncompatible // Iterables.filter(Iterable, Class)
  public void testFilterByType() throws Exception {
    HasBoth hasBoth = new HasBoth();
    FluentIterable<TypeA> alist =
        FluentIterable.from(asList(new TypeA(), new TypeA(), hasBoth, new TypeA()));

    }

    /**
     * Converts an object to the specified type.
     * Supports conversion to String, Date, Long, Integer, Double, Float, and Boolean types.
     *
     * @param <T> the type to convert the value to
     * @param value the value to convert
     * @param clazz the target class type
     * @return the converted value or null if conversion is not supported
     */