@Override
            public void convert(String notation, NotationConvertResult<? super File> result) throws TypeConversionException {
                result.converted(fileResolver.resolve(notation));
            }
        }), File.class);
        registerConverters();
    }

    @Override
    public Object convert(Object notation, Class<?> type, boolean primitive) throws TypeConversionException {

            allConflicts.add(buildConflict(owner, selectionReason));
        }
    }

    private static Conflict buildConflict(DependencyGraphComponent owner, ComponentSelectionReason selectionReason) {
        ModuleIdentifier module = owner.getModuleVersion().getModule();
        return new Conflict(ImmutableList.copyOf(owner.getAllVersions()), buildConflictMessage(module, selectionReason));
    }

class ConflictContainerTest extends Specification {

    @Subject container = new ConflictContainer<String, Integer>()

    def "no conflict when candidates are empty"() {
        def conflict = container.newElement('a', [], null)

        expect:
        conflict == null
        container.size == 0
    }

    def "contains few unconflicted elements"() {
        container.newElement("a", [1], null)

// CHECK:         %[[ROUND:.*]] = f32[] round-nearest-even(f32[] %[[CLAMP]])
// CHECK:         %[[CONVERT_0:.*]] = u8[] convert(f32[] %[[ROUND]])
// CHECK:         %[[CONVERT_1:.*]] = s32[] convert(u8[] %[[CONVERT_0]])
// CHECK:         %[[SUB:.*]] = s32[] subtract(s32[] %[[CONVERT_1]],
// CHECK:         %[[CONVERT_2:.*]] = f32[] convert(s32[] %[[SUB]])
// CHECK:         %[[MUL:.*]] = f32[] multiply(f32[] %[[CONVERT_2]],

	newObjVersioned, err := f.toVersioned(newObj)
	if err != nil {
		return nil, nil, fmt.Errorf("failed to convert new object (%v) to proper version (%v): %v", objectGVKNN(newObj), f.groupVersion, err)
	}
	liveObjVersioned, err := f.toVersioned(liveObj)
	if err != nil {
		return nil, nil, fmt.Errorf("failed to convert live object (%v) to proper version: %v", objectGVKNN(liveObj), err)
	}

            failure.assertHasCause("""Module 'cglib:cglib-nodep' has been rejected:
   Cannot select module with conflict on capability 'cglib:cglib:3.2.5' also provided by [cglib:cglib:3.2.5($variant)]""")
        }

        where:
        fixConflict | description
        false       | 'conflict fix not applied'
        true        | 'conflict fix applied'
    }

    /**

        buildOptions.commandLineConverter().configure(parser);
    }

    public void convert(ParsedCommandLine commandLine, Map<String, String> properties, T target) {
        buildOptions.propertiesConverter().convert(properties, target);
        buildOptions.commandLineConverter().convert(commandLine, target);
    }

        when:
        converter.convert(12L, result)

        then:
        0 * _._
    }

    def "delegates to target when notation is an instance of the target type"() {
        when:
        converter.convert(12.0, result)

        then:
        1 * target.convert(12.0, result)
    }

	_ = i != 1 // ERROR "invalid operation.*mismatched types|incompatible types|cannot convert"
	_ = i >= 1 // ERROR "invalid operation.*mismatched types|incompatible types|cannot convert"
	_ = 1 == i // ERROR "invalid operation.*mismatched types|incompatible types|cannot convert"
	_ = 1 != i // ERROR "invalid operation.*mismatched types|incompatible types|cannot convert"

// Declare bridge passes that perform legalization and/or lowering.

include "mlir/Pass/PassBase.td"

def ConvertTFQuantOpsToMHLO : Pass<"quant-convert-tf-quant-ops-to-mhlo", "mlir::func::FuncOp"> {
  let summary = "Convert TF Quant ops to MHLO quantizated ops.";

  let description = [{
    Convert TF Quant ops to MHLO quant ops.
  }];

  let constructor = "mlir::quant::stablehlo::CreateConvertTFQuantOpsToMHLOPass()";