//    could process the following equation by setting the attributes properly:
//    abc,cd->abd.
// 4. The output should be in the form: [batch dims][lhs dims][rhs dims]
bool IsEinsumSupportedByXlaDotV2(StringAttr equation_attr) {
  StringRef equation = equation_attr.getValue();

  if (!absl::StrContains(equation, "->") || !absl::StrContains(equation, ",") ||

        def dir1 = tmpDir.createDir("dir1")
        def dir2 = tmpDir.createDir("dir2")
        def dir3 = tmpDir.createDir("dir3")

        given:
        vswhereInstall(dir1, "15.3.26730.16")
        vswhereInstall(dir2, "14.0")
        vswhereInstall(dir3, "12.0")

        when:
        VisualStudioInstallCandidate metadata = determiner.getVisualStudioMetadataFromInstallDir(dir2)

        then:

        1 * visitor.visitFile({ it.file == tempDir.file("dir2/file1") })
        1 * visitor.visitFile({ it.file == tempDir.file("dir2/file2") })
        1 * visitor.visitFile({ it.file == tempDir.file("dir2/file3") })
        1 * visitor.visitDir({ it.file == tempDir.file("dir2/dir1") })
        1 * visitor.visitDir({ it.file == tempDir.file("dir2/dir2") })

  llvm::SmallVector<int64_t, 4> dims;
  dims.reserve(lhs.getRank());
  for (auto dim : llvm::zip(lhs.getShape(), rhs.getShape())) {
    int64_t lhs_dim = std::get<0>(dim);
    if (lhs_dim == std::get<1>(dim)) {
      dims.push_back(lhs_dim);
    } else {
      dims.push_back(ShapedType::kDynamic);
    }
  }
  return tensorflow::GetTypeFromTFTensorShape(
      dims, GetElementTypeFromOperand(lhs, rhs));
}

        def dir1 = parent.createDir("dir1")
        def dir2 = parent.createDir("sub/more/dir2")
        def dir2File = dir2.file("existing").createFile()
        def dir2FileSibling = dir2.file("sibling").createFile()
        def dir3 = parent.createDir("sub/more/dir3")
        def fullSet = snapshot(dir1, dir2, dir3)

        when:
        def set = invalidate(fullSet, dir2)
        then:
        assertDirectorySnapshot(set, dir1)

				"dir/",
				"dir/file",
				"dir2/",
				"file2",
			},
			false,
		},
		{
			"mount",
			[]string{
				"dir/",
				"dir/file",
				"dir2/",
				"file2",
				"mount/",
				"mount/file3",
			},
			true,
		},
		{
			"innermount",
			[]string{
				"dir/",
				"dir/file",
				"dir/dir2/",
				"dir/dir2/file2",
				"dir/dir2/mount/",
				"dir/dir2/mount/file3",
			},

        def platformSdk = result.component.forPlatform(x64())
        platformSdk.includeDirs == [ dir2.file("Include/10.0.10150.0/um"), dir2.file("Include/10.0.10150.0/shared") ]
    }

    def "uses windows SDK using specified install dir"() {
        def dir1 = kitDir("sdk1", "10.0.10240.0")
        def dir2 = kitDir("sdk2", "10.0.10150.0")
        def dir3 = kitDir("sdk3", "10.0.10500.0")

        given:

TF_CAPI_EXPORT extern TF_DataType TF_CheckpointReaderGetVariableDataType(
    TF_CheckpointReader* reader, const char* name);
// Read the shape of a variable and write to `dims`
TF_CAPI_EXPORT extern void TF_CheckpointReaderGetVariableShape(
    TF_CheckpointReader* reader, const char* name, int64_t* dims, int num_dims,
    TF_Status* status);
// Get the number of dimension of a variable
TF_CAPI_EXPORT extern int TF_CheckpointReaderGetVariableNumDims(

    int default_spatial_dim_start, int num_spatial_dims, RankedTensorType type,
    ConversionPatternRewriter& rewriter);

// Insert transpose so the input value is converted to the format specified by
// the default dims
Value InsertTranspose(Value value, int batch_dim, int feature_dim,
                      ArrayRef<int64_t> spatial_dimensions,
                      int default_batch_dim, int default_feature_dim,

        set.srcDirs equalTo([new File(testDir, 'dir1')] as Set)
    }

    void addsResolvedSourceDirectories() {
        when:
        set.srcDir {-> ['dir1', 'dir2'] }

        then:
        set.srcDirs equalTo([new File(testDir, 'dir1'), new File(testDir, 'dir2')] as Set)
    }

    void addsContentsOfAnotherSourceDirectorySet() {