import java.util.Map;

class GccPlatformToolProvider extends AbstractPlatformToolProvider {

    private static final Map<ToolType, String> LANGUAGE_FOR_COMPILER = ImmutableMap.of(
        ToolType.C_COMPILER, "c",
        ToolType.CPP_COMPILER, "c++",
        ToolType.OBJECTIVEC_COMPILER, "objective-c",
        ToolType.OBJECTIVECPP_COMPILER, "objective-c++"
    );

    private final ToolSearchPath toolSearchPath;

        and:
        toolSearchPath.locate(toolType, _) >> tool
        toolSearchPath.locate(_, _) >> missing
        metaDataProvider.getCompilerMetaData(_, _) >> correctCompiler

        expect:
        toolChain.select(platform).available

        where:
        toolType << [ToolType.C_COMPILER, ToolType.CPP_COMPILER, ToolType.OBJECTIVEC_COMPILER, ToolType.OBJECTIVECPP_COMPILER]
    }

    public String getExecutableSymbolFileName(String executablePath) {
        return withExtension(getExecutableName(executablePath), ".pdb");
    }

    @Override
    public VisualCppMetadata getCompilerMetadata(ToolType toolType) {
        return new VisualCppMetadata() {
            @Override
            public VersionNumber getVisualStudioVersion() {
                return visualStudio.getVersion();
            }

        toolChain.add(instantiator.newInstance(DefaultGccCommandLineToolConfiguration.class, ToolType.CPP_COMPILER, "g++"));
        toolChain.add(instantiator.newInstance(DefaultGccCommandLineToolConfiguration.class, ToolType.LINKER, "g++"));
        toolChain.add(instantiator.newInstance(DefaultGccCommandLineToolConfiguration.class, ToolType.STATIC_LIB_ARCHIVER, "ar"));

		cel.Overload("ip_is_canonical", []*cel.Type{cel.StringType}, cel.BoolType,
			cel.UnaryBinding(ipIsCanonical)),
	},
	"isUnspecified": {
		cel.MemberOverload("ip_is_unspecified", []*cel.Type{apiservercel.IPType}, cel.BoolType,
			cel.UnaryBinding(isUnspecified)),
	},
	"isLoopback": {
		cel.MemberOverload("ip_is_loopback", []*cel.Type{apiservercel.IPType}, cel.BoolType,
			cel.UnaryBinding(isLoopback)),
	},

		cel.Overload("is_quantity_string", []*cel.Type{cel.StringType}, cel.BoolType, cel.UnaryBinding(isQuantity)),
	},
	"sign": {
		cel.Overload("quantity_sign", []*cel.Type{apiservercel.QuantityType}, cel.IntType, cel.UnaryBinding(quantityGetSign)),
	},
	"isGreaterThan": {
		cel.MemberOverload("quantity_is_greater_than", []*cel.Type{apiservercel.QuantityType, apiservercel.QuantityType}, cel.BoolType, cel.BinaryBinding(quantityIsGreaterThan)),
	},

type FloatType struct {
	BasicType
}

// A ComplexType represents a complex floating point type.
type ComplexType struct {
	BasicType
}

// A BoolType represents a boolean type.
type BoolType struct {
	BasicType
}

// An AddrType represents a machine address type.
type AddrType struct {
	BasicType
}

	"errored": {
		cel.MemberOverload("decision_errored", []*cel.Type{DecisionType}, cel.BoolType,
			cel.UnaryBinding(decisionErrored))},
	"error": {
		cel.MemberOverload("decision_error", []*cel.Type{DecisionType}, cel.StringType,
			cel.UnaryBinding(decisionError))},
	"allowed": {
		cel.MemberOverload("decision_allowed", []*cel.Type{DecisionType}, cel.BoolType,
			cel.UnaryBinding(decisionAllowed))},
	"reason": {

		field("name", apiservercel.StringType, true),
		field("namespace", apiservercel.StringType, false),
		field("operation", apiservercel.StringType, true),
		field("userInfo", userInfoType, true),
		field("dryRun", apiservercel.BoolType, false),
		field("options", apiservercel.DynType, false),
	))
}

// BuildNamespaceType generates a DeclType for Namespace.

	Expression string
}

func (v *fakeValidationCondition) GetExpression() string {
	return v.Expression
}

func (v *fakeValidationCondition) ReturnTypes() []*celgo.Type {
	return []*celgo.Type{celgo.BoolType}
}

type fakeAuditAnnotationCondition struct {
	ValueExpression string
}

func (v *fakeAuditAnnotationCondition) GetExpression() string {
	return v.ValueExpression
}