"has-tostringtag": "^1.0.0"
      },
      "engines": {
        "node": ">= 0.4"
      }
    },
    "node_modules/es-to-primitive": {
      "version": "1.2.1",
      "resolved": "https://registry.npmjs.org/es-to-primitive/-/es-to-primitive-1.2.1.tgz",
      "integrity": "sha512-QCOllgZJtaUo9miYBcLChTUaHNjJF3PYs1VidD7AwiEj1kYxKeQTctLAezAOH5ZKRH0g2IgPn6KwB4IT8iRpvA==",
      "dev": true,

        'empty-segments' : 'Empty segments',
        'validation:property-validation:annotation-invalid-in-context' : 'Invalid annotation in context',
        'validation:property-validation:cannot-use-optional-on-primitive-types' : 'Property should be annotated with @Optional',
        'validation:property-validation:cannot-write-output' : 'Property is not writable',

        !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" }'

type Decrypter interface {
	// Public returns the public key corresponding to the opaque,
	// private key.
	Public() PublicKey

	// Decrypt decrypts msg. The opts argument should be appropriate for
	// the primitive used. See the documentation in each implementation for
	// details.
	Decrypt(rand io.Reader, msg []byte, opts DecrypterOpts) (plaintext []byte, err error)
}

  pm.addNestedPass<mlir::func::FuncOp>(
      mlir::mhlo::createLegalizeEinsumToDotGeneralPass());
  pm.addNestedPass<mlir::func::FuncOp>(
      mlir::mhlo::createLegalizeDotToDotGeneralPass());
  // Unfuse mhlo BatchNorm to primitive ops.
  pm.addNestedPass<mlir::func::FuncOp>(mlir::odml::createUnfuseBatchNormPass());
  // Fuse Conv + Mul to Conv.
  pm.addNestedPass<mlir::func::FuncOp>(mlir::odml::createFuseConvolutionPass());

        then:
        //we do not know which 'myProperty' setter is picked, as both fit equally well
        noExceptionThrown()
    }

    def "cannot write primitive type properties if type is unknown"() {
        when:
        writeableProperty(JavaTestSubject, "myBooleanProperty", null)

        then:
        def e = thrown(NoSuchPropertyException)

    if (isPrimitive()) {
      @SuppressWarnings("unchecked") // this is a primitive class
      Class<T> type = (Class<T>) runtimeType;
      return of(Primitives.wrap(type));
    }
    return this;
  }

  private boolean isWrapper() {
    return Primitives.allWrapperTypes().contains(runtimeType);
  }

  /**
   * Returns the corresponding primitive type if this is a wrapper type; otherwise returns {@code

    }

    @Override
    public Object get() {
        return value.isolate();
    }

    @Nullable
    private String desugar() {
        // We support desugaring for all non-primitive types supported in GradleModuleMetadataWriter.writeAttributes(), which are:
        // - Named
        // - Enum
        if (Named.class.isAssignableFrom(attribute.getType())) {
            return ((Named) get()).getName();