StringAttr replication_attr = GetReplicationAttr(*forward_pass_ops.begin());
  llvm::SmallVector<Operation*> checkset(forward_pass_ops.getArrayRef());
  checkset.append(backward_pass_ops.begin(), backward_pass_ops.end());
  for (Operation* op : checkset) {
    if (op->getParentRegion() != region) {
      op->emitOpError() << "embedding ops in two different regions";
      return signalPassFailure();

	ChecksumSHA256
	// ChecksumSHA1 indicates a SHA-1 checksum.
	ChecksumSHA1
	// ChecksumCRC32 indicates a CRC32 checksum with IEEE table.
	ChecksumCRC32
	// ChecksumCRC32C indicates a CRC32 checksum with Castagnoli table.
	ChecksumCRC32C
	// ChecksumInvalid indicates an invalid checksum.
	ChecksumInvalid
	// ChecksumMultipart indicates the checksum is from a multipart upload.
	ChecksumMultipart

	containerRuntime := utilruntime.NewContainerRuntime(nodeReg.CRISocket)
	if err := containerRuntime.Connect(); err != nil {
		klog.Warningf("[preflight] WARNING: Couldn't create the interface used for talking to the container runtime: %v\n", err)
	} else {
		checks = append(checks, ContainerRuntimeCheck{runtime: containerRuntime})
	}

	// non-windows checks
	checks = addSwapCheck(checks)

                expectGetArtifact(classifier: 'jdk8')
            }
            'org.test:moduleB:1.0' {
                expectResolve()
            }
        }

        then:
        succeeds 'checkDep'
        def expectedLibraryAttributes = expectedJavaLibraryAttributes(useMaven() || gradleMetadataPublished)
        resolve.expectGraph {
            root(':', ':test:') {
                module('org.test:moduleA:1.0') {

		}

		if err := DB.Create(&pet).Error; err != nil {
			t.Fatalf("errors happened when create: %v", err)
		}

		CheckPet(t, pet, pet)

		var pet2 Pet
		DB.Preload("Toy").Find(&pet2, "id = ?", pet.ID)
		CheckPet(t, pet2, pet)
	})

	t.Run("Slice", func(t *testing.T) {
		pets := []Pet{{
			Name: "PolymorphicHasOne-Slice-1",

        repositoryInteractions {
            'a:a:1.0' { expectResolve() }
            'b:b:1.0' { expectResolve() }
            'c:c:1.0' { expectResolve() }
        }

        when:
        succeeds "checkDep"

        then:
        resolve.expectGraph {
            root(":", ":test:") {
                module("a:a:1.0") {
                    module("b:b:1.0")
                    module("c:c:1.0")
                }

            .dependsOn(notRequired, scope: 'provided')
            .publish()

        buildFile << """
dependencies {
    conf 'test:target:1.0'
}
"""
        expect:
        succeeds 'checkDep'
        resolve.expectDefaultConfiguration("runtime")
        resolve.expectGraph {
            root(':', ':testproject:') {
                module('test:target:1.0') {
                    module('test:test5:1.0') {

        buildFile << """
            dependencies {
                compile "group:moduleA"
                compile platform("group:bom:1.0")
            }
        """

        when:
        succeeds 'checkDep'

        then:
        resolve.expectGraph {
            root(':', ':testproject:') {
                module("group:bom:1.0:platform-runtime") {
                    constraint("group:moduleA:2.0", "group:moduleA:2.0")

			}
			m.addErrorNonBlockingClose(errResp, context.Cause(m.ctx))
			return
		case <-pingTimer:
			errState = !m.doPing(errResp)
		}
	}
}

// checkSeq will check if sequence number is correct and increment it by 1.
func (m *muxClient) checkSeq(seq uint32) (ok bool) {
	if seq != m.RecvSeq {
		if debugPrint {
			fmt.Printf("MuxID: %d client, expected sequence %d, got %d\n", m.MuxID, m.RecvSeq, seq)
		}

			getOptions: GetOptions{
				Checksum:        cacheHitSum,
				ResourceName:    "namespace.resource",
				ResourceVersion: "0",
				RequestTimeout:  time.Second * 10,
			},
			wantCachedModules: map[moduleKey]*cacheEntry{
				{name: ts.URL, checksum: cacheHitSum}: {modulePath: "test.wasm"},
			},
			wantCachedChecksums: map[string]*checksumEntry{