// if there is an interface, the other type must implement the
	// interface.
	exact
)

func (m unifyMode) String() string {
	switch m {
	case 0:
		return "inexact"
	case assign:
		return "assign"
	case exact:
		return "exact"
	case assign | exact:
		return "assign, exact"
	}
	return fmt.Sprintf("mode %d", m)
}

	// if there is an interface, the other type must implement the
	// interface.
	exact
)

func (m unifyMode) String() string {
	switch m {
	case 0:
		return "inexact"
	case assign:
		return "assign"
	case exact:
		return "exact"
	case assign | exact:
		return "assign, exact"
	}
	return fmt.Sprintf("mode %d", m)
}

func (q *Quantity) RoundUp(scale Scale) bool {
	if q.d.Dec != nil {
		q.s = ""
		d, exact := q.d.AsScale(scale)
		q.d = d
		return exact
	}
	// avoid clearing the string value if we have already calculated it
	if q.i.scale >= scale {
		return true
	}
	q.s = ""
	i, exact := q.i.AsScale(scale)
	q.i = i
	return exact
}

// Add adds the provide y quantity to the current value. If the current value is zero,

		if x.neg {
			var z float64
			return -z, Exact
		}
		return 0.0, Exact

	case inf:
		if x.neg {
			return math.Inf(-1), Exact
		}
		return math.Inf(+1), Exact
	}

	panic("unreachable")
}

// Int returns the result of truncating x towards zero;
// or nil if x is an infinity.
// The result is [Exact] if x.IsInt(); otherwise it is [Below]

//
// Before wildcards were introduced, it was clear that an exact match meant
// that the pattern and path were the same string. The only other possibility
// was that a trailing-slash pattern, like "/", matched a path longer than
// it, like "/a".
//
// With wildcards, we define an inexact match as any one where a multi wildcard
// matches a non-empty string. All other matches are exact.
// For example, these are all exact matches:
//

            [':a', ':b', ':d', ':f', ':e', ':c'],
            []
        ]
    }

    def "can specify a task more than once in a complex rule"() {
        def spec = any(exact(':a', ':c'), exact(':b', ':d'), exact(':a', ':d'))

        given:
        assert spec.getTasks() == [':a', ':b', ':c', ':d'] as Set

        when:
        spec.assertMatches(-1, [':a', ':b', ':c', ':d'])

        then:

                    stringMatch:
                      exact: rule[0]-to[0]-method[1]
                - header:
                    name: :method
                    stringMatch:
                      exact: rule[0]-to[0]-method[2]
            - orRules:
                rules:
                - urlPath:
                    path:
                      exact: rule[0]-to[0]-path[1]
                - urlPath:

                rules:
                - header:
                    name: :method
                    stringMatch:
                      exact: GET
                - header:
                    name: :method
                    stringMatch:
                      exact: POST
        principals:
        - andIds:
            ids:
            - any: true
      ns[foo]-policy[httpbin-2]-rule[0]:
        permissions:

			want: authz.MetadataMatcherForJWTClaims([]string{"key1"}, authzmatcher.StringMatcher("exact"), false),
		},
		{
			name: "@request.auth.claims.key1.KEY2",
			in:   &networking.StringMatch{MatchType: &networking.StringMatch_Exact{Exact: "exact"}},
			want: authz.MetadataMatcherForJWTClaims([]string{"key1", "KEY2"}, authzmatcher.StringMatcher("exact"), false),
		},
		{

                    principalName:
                      exact: spiffe://td1/ns/rule[0]/sa/from[0]-principal[0]
                - authenticated:
                    principalName:
                      exact: spiffe://cluster.local/ns/rule[0]/sa/from[0]-principal[0]
                - authenticated:
                    principalName:
                      exact: spiffe://some-td/ns/rule[0]/sa/from[0]-principal[0]
        - andIds: