* before failing.
 *
 * The last one is "off", meaning that even if verification metadata is
 * present, Gradle will not perform any verification. This can typically
 * be used whenever verification should only happen on CI.
 *
 * @since 6.2
 */
public enum DependencyVerificationMode {
    STRICT, // the default, fail as soon as possible
    LENIENT, // do not fail, but report all verification failures on console

        synchronized (lock) {
            testInternal = executing.get(failure.getDescription());
        }
        boolean needEndEvent = false;
        if (testInternal == null) {
            // This can happen when, for example, a @BeforeClass or @AfterClass method fails
            needEndEvent = true;
            testInternal = descriptor;
            resultProcessor.started(testInternal, startEvent());
        }

                    toList(result.getArtifacts()),
                    result.getMissingArtifacts(),
                    request.getRemoteRepositories());
        }

        // this should never happen since we checked all possible error sources before but better be sure
        if (result.hasExceptions()) {
            throw new ArtifactResolutionException(

                VersionRange.createFromVersion("1.0"),
                "type",
                null,
                "system",
                "compile");

        // this one should never happen in practice...
        Artifact artifact5 = factory.createDependencyArtifact(
                "test-grp", "test-artifact-5", VersionRange.createFromVersion("1.0"), "type", null, "system", "system");

    }

    /**
     * The version of the sub-hierarchy at the given location.
     *
     * The version increases if there is any updated version in a parent or descendant of the location.
     * Version updates happen via {@link #updateVersion(String)}.
     */
    public long getVersion(String location) {
        VfsRelativePath relativePath = VfsRelativePath.of(location);
        return relativePath.isEmpty()

	UpdatedAt  time.Time
}

func TestNonStdPrimaryKeyAndDefaultValues(t *testing.T) {
	DB.Migrator().DropTable(&Animal{})
	if err := DB.AutoMigrate(&Animal{}); err != nil {
		t.Fatalf("no error should happen when migrate but got %v", err)
	}

	animal := Animal{Name: "Ferdinand"}
	DB.Save(&animal)
	updatedAt1 := animal.UpdatedAt

	DB.Save(&animal).Update("name", "Francis")

   *
   * <p><b>Warning:</b> On a file system that supports symbolic links, it is possible for an
   * insecure recursive delete to delete files and directories that are <i>outside</i> the directory
   * being deleted. This can happen if, after checking that a file is a directory (and not a
   * symbolic link), that directory is deleted and replaced by a symbolic link to an outside

            } else {
                return null;
            }
        } catch (NativeException ex) {
            // if a native terminal exists but cannot be resolved, use dumb terminal settings
            // this can happen if a terminal is in use that does not have its terminfo installed
            return null;
        }
    }

    @Override
    public boolean isConsoleInput() {
        return terminals.isTerminalInput();
    }

		t.Errorf("Age soft deleted record, expects: %v, got: %v", 0, age)
	}

	if err := DB.Delete(&user).Error; err != nil {
		t.Fatalf("No error should happen when soft delete user, but got %v", err)
	}

	if sql.NullTime(user.DeletedAt).Time.IsZero() {
		t.Fatalf("user's deleted at is zero")
	}

	return nil
}

func (b *streamingBitrotReader) ReadAt(buf []byte, offset int64) (int, error) {
	var err error
	if offset%b.shardSize != 0 {
		// Offset should always be aligned to b.shardSize
		// Can never happen unless there are programmer bugs
		return 0, errUnexpected
	}
	if b.rc == nil {
		// For the first ReadAt() call we need to open the stream for reading.
		b.currOffset = offset