return builder.toString();
  }

  /**
   * Returns a comparator that compares two {@code char} arrays <a
   * href="http://en.wikipedia.org/wiki/Lexicographical_order">lexicographically</a>; not advisable
   * for sorting user-visible strings as the ordering may not match the conventions of the user's
   * locale. That is, it compares, using {@link #compare(char, char)}), the first pair of values

	if gotTv.Type == nil {
		t.Errorf("Eval(%q) got nil type but no error", expr)
		return
	}

	// compare types
	if typ != nil {
		// we have a type, check identity
		if !Identical(gotTv.Type, typ) {
			t.Errorf("Eval(%q) got type %s, want %s", expr, gotTv.Type, typ)
			return
		}
	} else {
		// we have a string, compare type string
		gotStr := gotTv.Type.String()
		if gotStr != typStr {

        // If there are different output properties compared to the previous execution, then we do have output changes
        if (!previous.keySet().equals(current.keySet())) {
            return true;
        }

        // Otherwise, do deep compare of outputs
        ChangeDetectorVisitor visitor = new ChangeDetectorVisitor();

func (sl addrsReady) Less(i, j int) bool {
	return lessAddrReady(sl[i], sl[j])
}

// LessEndpointAddress compares IP addresses lexicographically and returns true if first argument is lesser than second
func LessEndpointAddress(a, b *v1.EndpointAddress) bool {
	ipComparison := bytes.Compare([]byte(a.IP), []byte(b.IP))
	if ipComparison != 0 {
		return ipComparison < 0
	}
	if b.TargetRef == nil {
		return false

        compare("incoming.artifacts.artifacts", actualArtifacts, expectedArtifacts)

        if (buildArtifacts) {
            def actualFiles = findLines(configDetails, 'file-file')
            compare("files", actualFiles, expectedFiles)

            actualFiles = findLines(configDetails, 'file-filtered')
            compare("files (filtered)", actualFiles, expectedFiles)

      builder.append(separator).append(array[i]);
    }
    return builder.toString();
  }

  /**
   * Returns a comparator that compares two {@code int} arrays <a
   * href="http://en.wikipedia.org/wiki/Lexicographical_order">lexicographically</a>. That is, it
   * compares, using {@link #compare(int, int)}), the first pair of values that follow any common

	"unsafe"
)

// This file contains code generation tests related to the comparison
// operators.

// -------------- //
//    Equality    //
// -------------- //

// Check that compare to constant string use 2/4/8 byte compares

func CompareString1(s string) bool {
	// amd64:`CMPW\t\(.*\), [$]`
	// arm64:`MOVHU\t\(.*\), [R]`,`MOVD\t[$]`,`CMPW\tR`
	// ppc64le:`MOVHZ\t\(.*\), [R]`,`CMPW\t.*, [$]`

        def compared = PathUtil.getPathComparator(CASE_SENSITIVE).compare(path1, path2)
        def entry1 = new ChildMap.Entry<FileSystemNode>(path1, child1)
        def entry2 = new ChildMap.Entry<FileSystemNode>(path2, child2)
        return compared < 0 ? ChildMapFactory.childMapFromSorted([entry1, entry2]) : ChildMapFactory.childMapFromSorted([entry2, entry1])

	VSLDOI   $2, V2, V3, V9     // V9=(V2:V3)<<2
	VSLDOI   $3, V2, V3, V10    // V10=(V2:v3)<<3
	VCMPEQUW V1, V2, V5         // compare index 0, 4, ... with sep
	VCMPEQUW V1, V4, V6         // compare index 1, 5, ... with sep
	VCMPEQUW V1, V9, V11        // compare index 2, 6, ... with sep
	VCMPEQUW V1, V10, V12       // compare index 3, 7, ... with sep
	VSEL     V6, V5, V29, V13   // merge index 0, 1, 4, 5, using mask

      builder.append(separator).append(array[i]);
    }
    return builder.toString();
  }

  /**
   * Returns a comparator that compares two {@code long} arrays <a
   * href="http://en.wikipedia.org/wiki/Lexicographical_order">lexicographically</a>. That is, it
   * compares, using {@link #compare(long, long)}), the first pair of values that follow any common