public <S> S coerce(Class<S> type) {
        return null;
    }

    private byte getPrimitiveTypeCode() {
        return (byte) primitiveType.ordinal();
    }

    /**
     * The primitive array type.
     * <br>
     * <b>IMPORTANT: the order in which the enums are defined here matters and should be considered part of the
     * cross-version protocol since the {@link Enum#ordinal()} is part of the

      derWriter.writeUtf8("a".repeat(201))
    }

    assertThat(buffer.readByteString(3)).isEqualTo("1e81c9".decodeHex())
    assertThat(buffer.readUtf8()).isEqualTo("a".repeat(201))
  }

  @Test fun `decode primitive bit string`() {
    val buffer =
      Buffer()
        .write("0307040A3B5F291CD0".decodeHex())

    val derReader = DerReader(buffer)

    derReader.read("test") { header ->

        'theLong'       | Long
        'thelong'       | long
        'theshort'      | short
        'theShort'      | Short
        'thebyte'       | byte
        'theByte'       | Byte
    }

    void 'primitive types cannot accept null values'() {
        when:
        buildFile << CLASSES
        buildFile << """
            model {
                props {
                    $varname = null
                }

            .and(not(inGradlePublicApiPackages()))
            .and(not(inTestFixturePackages()))
            .as("in Gradle internal API packages");
    }

    DescribedPredicate<JavaClass> primitive = new DescribedPredicate<JavaClass>("primitive") {
        @Override
        public boolean test(JavaClass input) {
            return input.isPrimitive();
        }
    };

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.internal.configuration.inputs;

import com.google.common.primitives.Primitives;

import javax.annotation.Nullable;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintStream;
import java.io.PrintWriter;
import java.io.Reader;

 *
 * <ul>
 *   <li>If all the values you want to summarize are already known, use the appropriate {@code
 *       Stats.of} factory method below. Primitive arrays, iterables and iterators of any kind of
 *       {@code Number}, and primitive varargs are supported.
 *   <li>Or, to avoid storing up all the data first, create a {@link StatsAccumulator} instance,

[[cannot_use_optional_on_primitive_types]]
== Invalid use of @Optional annotation on primitive types

This error indicates that a property of primitive type is also annotated with `@Optional`.
This is similar to `null` not being assignable to primitive types in Java.

To fix this problem, you have two options:

- remove the `@Optional` annotation

        !propertyNames.contains("notString")
    }

    /**
     * See <a href="https://issues.apache.org/jira/browse/GROOVY-10708">GROOVY-10708</a>
     */
    def "is methods with non-primitive boolean return type are not considered properties by Gradle, Groovy nor Java"() {
        assumeTrue('This test requires bundled Groovy 4 or later', VersionNumber.parse(GroovySystem.version).major >= 4)

        given:

namespace mlir::quantfork {

// Performs type conversion from an arbitrary input type to a type
// that is expressed by a QuantizedType.
//
// This handles cases where the inputType is a supported primitive type
// (i.e. f32, bf16, etc) or a vector/tensor type based on a supported
// elemental type.
//
// Since conversion often involves introspecting some attributes of the

        where:
        [operator, orElseKind] << [
            ['systemProperty', 'environmentVariable'],
            ['primitive', 'provider', 'task output']
        ].combinations()
        orElseArgument = orElseKind == 'primitive'
            ? '"absent"'
            : orElseKind == 'provider'
            ? 'providers.provider { "absent" }'