package strings

import "internal/bytealg"

// Compare returns an integer comparing two strings lexicographically.
// The result will be 0 if a == b, -1 if a < b, and +1 if a > b.
//
// Use Compare when you need to perform a three-way comparison (with
// slices.SortFunc, for example). It is usually clearer and always faster
// to use the built-in string comparison operators ==, <, >, and so on.
func Compare(a, b string) int {

		}
		return n
	case types.TARRAY:
		// We can compare several elements at once with 2/4/8 byte integer compares
		inline = t.NumElem() <= 1 || (types.IsSimple[t.Elem().Kind()] && (t.NumElem() <= 4 || t.Elem().Size()*t.NumElem() <= maxcmpsize))
	case types.TSTRUCT:
		inline = compare.EqStructCost(t) <= 4
	}

	cmpl := n.X
	for cmpl != nil && cmpl.Op() == ir.OCONVNOP {

// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

package compare

import (
	"fmt"
	"io"
	"path/filepath"
	"reflect"
	"regexp"
	"sort"
	"strings"

	"github.com/google/go-cmp/cmp"
	"sigs.k8s.io/yaml"

	"istio.io/istio/operator/pkg/object"

compare-small.svg...

compare-small-b.svg...

	switch m {
	case M(nil): // ERROR "compare.*to nil|operator \=\= not defined for .|cannot compare"
	}

	_ = f == F(nil) // ERROR "compare.*to nil|operator \=\= not defined for .|cannot compare"
	_ = F(nil) == f // ERROR "compare.*to nil|operator \=\= not defined for .|cannot compare"
	switch f {
	case F(nil): // ERROR "compare.*to nil|operator \=\= not defined for .|cannot compare"
	}

                .compare(1.0, 1.0)
                .compare(1.0f, 1.0f)
                .compare("a", "a", Ordering.usingToString())
                .result())
        .isEqualTo(0);
  }

  public void testShortCircuitLess() {
    assertThat(
            ComparisonChain.start()
                .compare("a", "b")
                .compare(DONT_COMPARE_ME, DONT_COMPARE_ME)
                .result())

//   - bool compares false before true
//   - complex compares real, then imag
//   - pointers compare by machine address
//   - channel values compare by machine address
//   - structs compare each field in turn
//   - arrays compare each element in turn.
//     Otherwise identical arrays compare by length.
//   - interface values compare first by reflect.Type describing the concrete type

		}
		if b != (test.compare < 0) {
			t.Errorf("Less(%v, %v) == %t, want %t", test.x, test.y, b, test.compare < 0)
		}
	}
}

func TestCompare(t *testing.T) {
	for _, test := range tests {
		var c int
		switch test.x.(type) {
		case int:
			c = cmp.Compare(test.x.(int), test.y.(int))
		case string:
			c = cmp.Compare(test.x.(string), test.y.(string))
		case float64:

    def 'case for special qualifiers is ignored'() {
        expect:
        compare("1.0-rc", "1.0.RC") == 0
        compare("1.0-rc-1", "1.0.RC.1") == 0
        compare("1.0-snapshot", "1.0.SNAPSHOT") == 0
        compare("1.0-final", "1.0.FINAL") == 0
        compare("1.0-ga", "1.0.GA") == 0
        compare("1.0-release", "1.0.RELEASE") == 0
        compare("1.0-sp", "1.0.SP") == 0
    }