Graph graph2 = new Graph();
        addEdge(graph2, "a", "b");
        addEdge(graph2, "b", "c");
        CycleDetectedException cde = assertThrows(CycleDetectedException.class, () -> addEdge(graph2, "c", "a"));
        List<String> cycle = cde.getCycle();
        assertNotNull(cycle, "Cycle should be not null");
        assertTrue(cycle.contains("a"), "Cycle contains 'a'");

        configureMetadataForEtagMatch(remote, "cde")

        when:
        compare(local, remote)

        then:
        !unchanged
    }

    def "non matching etags, matching mod date, but different content length does not match"() {
        given:
        configureMetadata(local, "abc", now, -1)
        configureMetadataForEtagMatch(remote, "cde")

        when:
        compare(local, remote)

  %0 = mhlo.constant dense<(1.000000e+00,-1.000000e+00)> : tensor<128x32x4xcomplex<f32>>
  %1 = mhlo.constant dense<(1.000000e+00,1.000000e+00)> : tensor<8x64x128xcomplex<f32>>
  %2 = "mhlo.einsum"(%1, %0) <{einsum_config = "abc,cde->abde"}> : (tensor<8x64x128xcomplex<f32>>, tensor<128x32x4xcomplex<f32>>) -> tensor<8x64x32x4xcomplex<f32>>
  return %2 : tensor<8x64x32x4xcomplex<f32>>
}

// -----

    def canMatchFilesWithMultiplePatterns() {
        given:
        FileCopyDetails details1 = details('path/abc.txt')
        FileCopyDetails details2 = details('path/bcd.txt')
        FileCopyDetails details3 = details('path/cde.txt')

        Action matchingAction = Mock()

        when:
        copySpec.filesMatching(["**/a*", "**/c*"], matchingAction)
        copySpec.copyActions.each { copyAction ->
            copyAction.execute(details1)

        expect:
        hashKey(left) != hashKey(right)
    }

    def 'hash collision for strings'() {
        expect:
        hashStrings(["abc", "de"]) != hashStrings(["ab", "cde"])
    }

    def hashStrings(List<String> strings) {
        def hasher = Hashing.newHasher()
        strings.each { hasher.putString(it) }
        hasher.hash()
    }

  func.return %0 : tensor<?x2x4x5xf32>
}

// CHECK: func @xla_dot_v2
// CHECK: %[[einsum:.*]] = "tf.Einsum"(%arg0, %arg1) <{equation = "abc,cde->abde"}> : (tensor<?x2x3xf32>, tensor<3x4x5xf32>) -> tensor<?x2x4x5xf32>
// CHECK: return %[[einsum]] : tensor<?x2x4x5xf32>

// -----

// dimension_numbers: {
//   offset_dims: 0
//   collapsed_slice_dims: 1

		tests: []testFnc{
			testWrite{"ab", 2, nil},
			testRemaining{6, 3},
			testReadFrom{fileOps{int64(3), "cde"}, 6, nil},
			testRemaining{0, 0},
		},
	}, {
		maker: makeSparse{makeReg{5, "abcde"}, sparseHoles{{2, 3}}, 8},
		tests: []testFnc{
			testReadFrom{fileOps{"ab", int64(3), "cde"}, 8, nil},
			testRemaining{0, 0},
		},
	}, {
		maker: makeSparse{makeReg{5, "abcde"}, sparseHoles{{2, 3}}, 8},

    )

  def test_reuse_calibration_data(self):
    _, y_shape, bias_shape, x_signature, y_signature = (
        self._prepare_sample_einsum_datashapes('abc,cde->abde', use_bias=True)
    )

    self._create_einsum_model(
        self._input_saved_model_path,
        'abc,cde->abde',
        y_shape,
        x_signature,
        y_signature,
        bias_shape,
    )

    # Generate model input data.

	root, path, want string
}

var reltests = []RelTests{
	{"a/b", "a/b", "."},
	{"a/b/.", "a/b", "."},
	{"a/b", "a/b/.", "."},
	{"./a/b", "a/b", "."},
	{"a/b", "./a/b", "."},
	{"ab/cd", "ab/cde", "../cde"},
	{"ab/cd", "ab/c", "../c"},
	{"a/b", "a/b/c/d", "c/d"},
	{"a/b", "a/b/../c", "../c"},
	{"a/b/../c", "a/b", "../b"},
	{"a/b/c", "a/c/d", "../../c/d"},
	{"a/b", "c/d", "../../c/d"},

}


// -----

module {
  func.func @float_einsum(%arg0: tensor<?x64x32xf32>, %arg1: tensor<32x2x16xf32>) -> (tensor<?x64x2x16xf32>) {
    %0 = "tf.Einsum"(%arg0, %arg1) {equation = "abc,cde->abde"} : (tensor<?x64x32xf32>, tensor<32x2x16xf32>) -> tensor<?x64x2x16xf32>
    func.return %0 : tensor<?x64x2x16xf32>
  }

// CHECK-LABEL: func @float_einsum
// CHECK: -------- Quantization Summary --------