expected *networkingv1beta1.HTTPIngressPath
	}{
		"empty pathType should default to ImplementationSpecific": {
			original: &networkingv1beta1.HTTPIngressPath{},
			expected: &networkingv1beta1.HTTPIngressPath{PathType: &pathTypeImplementationSpecific},
		},
		"ImplementationSpecific pathType should not change": {
			original: &networkingv1beta1.HTTPIngressPath{PathType: &pathTypeImplementationSpecific},

      paths:
      - path: /productpage
        pathType: Exact
        backend:
          service:
            name: productpage
            port:
              number: 9080
      - path: /static/
        pathType: Prefix
        backend:
          service:
            name: productpage
            port:
              number: 9080
      - path: /login
        pathType: Exact
        backend:
          service:

public class AttributeMatchDetails {
    private final MatchType matchType;
    @Nullable
    private final Attribute<?> requested;
    @Nullable
    private final Object requestedValue;

    public AttributeMatchDetails(MatchType matchType, @Nullable Attribute<?> requested, @Nullable Object requestedValue) {
        this.matchType = matchType;
        this.requested = requested;

              number: 4205
      # Subpath without trailing /, Exact match
      - path: /sub/path
        pathType: Exact
        backend:
          service:
            name: service1
            port:
              number: 4206
        # With a trailing /, Exact match
      - path: /sub/path/
        pathType: Exact
        backend:
          service:
            name: service1
            port:

						MatchType: &networking.StringMatch_Regex{Regex: "test"},
					},
				},
			}},
		}, valid: true},
		{name: "regex without headers match ?", route: &networking.HTTPRoute{
			Redirect: &networking.HTTPRedirect{
				Uri:       "/",
				Authority: "foo.biz",
			},
			Match: []*networking.HTTPMatchRequest{{
				WithoutHeaders: map[string]*networking.StringMatch{
					"header": {

							Uri: &networking.StringMatch{
								MatchType: &networking.StringMatch_Prefix{Prefix: "/productpage/v2"},
							},
							Headers: map[string]*networking.StringMatch{
								"version": {
									MatchType: &networking.StringMatch_Exact{Exact: "v2"},
								},
							},
							Port: 8080,
						},
						{
							Uri: &networking.StringMatch{
								MatchType: &networking.StringMatch_Prefix{Prefix: "/productpage"},

        IVY      | PathType.ABSOLUTE
        IVY      | PathType.RELATIVE
        MAVEN    | PathType.ABSOLUTE
        MAVEN    | PathType.RELATIVE
    }

    def "can access classes from plugin from #repoType repo"() {
        given:
        publishTestPlugin(repoType)
        buildScript """
          plugins {
              id "org.example.plugin" version "1.0"
          }

				ing.Spec.Rules[0].IngressRuleValue.HTTP.Paths[0].PathType = &pathTypeFoo
			},
			expectErrsOnFields: []string{
				"spec.rules[0].http.paths[0].pathType",
			},
		},
		"empty path (prefix)": {
			tweakIngress: func(ing *networking.Ingress) {
				ing.Spec.Rules[0].IngressRuleValue.HTTP.Paths[0].Path = ""
				ing.Spec.Rules[0].IngressRuleValue.HTTP.Paths[0].PathType = &pathTypePrefix
			},
			expectErrsOnFields: []string{

	return RegisterDefaults(scheme)
}

func SetDefaults_HTTPIngressPath(obj *networkingv1beta1.HTTPIngressPath) {
	var defaultPathType = networkingv1beta1.PathTypeImplementationSpecific
	if obj.PathType == nil {
		obj.PathType = &defaultPathType
	}

}

// checkType checks whether the given path is the exact pathType
func checkType(path string, pathType *v1.HostPathType, hu hostutil.HostUtils) error {
	return checkTypeInternal(newFileTypeChecker(path, hu), pathType)
}

func checkTypeInternal(ftc hostPathTypeChecker, pathType *v1.HostPathType) error {
	switch *pathType {
	case v1.HostPathDirectoryOrCreate:
		if !ftc.Exists() {
			return ftc.MakeDir()