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 {

// 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...

                .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
    }

            0 * metaData.getLastModified()
            0 * metaData.getContentLength()
        }
    }
    boolean compare(ExternalResourceMetaData local, ExternalResourceMetaData remote) {
        compare(local, new Factory() {
            def create() { remote }
        })
    }

    boolean compare(ExternalResourceMetaData local, Factory<ExternalResourceMetaData> remoteFactory) {

	"istio.io/istio/operator/pkg/compare"
	"istio.io/istio/operator/pkg/util"
)

// YAMLSuffix is the suffix of a YAML file.
const YAMLSuffix = ".yaml"

type manifestDiffArgs struct {
	// compareDir indicates comparison between directory.
	compareDir bool
	// verbose generates verbose output.
	verbose bool
	// selectResources constrains the list of resources to compare to only the ones in this list, ignoring all others.