* It also deals relatively well when the system wall clock jumps forward by large amounts (this clock will jump with it).
 * It does not deal as well with large jumps back in time.
 * <p>
 * When the system wall clock jumps back in time, this clock will effectively slow down until it is back in sync.
 * All syncing timestamps will be the same as the previously issued timestamp.
 * The rate by which this clock slows, and therefore the time it takes to resync,

	// The rule is:
	// 1. Get all back-tick quoted names in the doc
	// 2. Skip the name which is already found mismatched.
	// 3. Skip the name whose lowercase is different from the lowercase of tag names,
	//    because some docs use back-tick to quote field value or nil
	// 4. Check if the name is different from its tag name

	// TODO: a manual pass adding back-ticks to the doc strings, then update the linter to

  }

  {nameDllVisualStudioProject, nameDllVisualStudioFilters, nameLibVisualStudioProject, nameLibVisualStudioFilters} -> visualStudio [dir=back, style=dashed]
  {nameVisualStudioProject, nameVisualStudioFilters} -> visualStudio [dir=back, style=dashed]
  nameVisualStudioSolution -> visualStudio -> openVisualStudio [dir=back]

  nameVisualStudioSolution[label=<<i>projectName</i>VisualStudioSolution>]

// MoveBefore moves element e to its new position before mark.
// If e or mark is not an element of l, or e == mark, the list is not modified.
// The element and mark must not be nil.
func (l *List) MoveBefore(e, mark *Element) {
	if e.list != l || e == mark || mark.list != l {
		return
	}
	l.move(e, mark.prev)
}

// MoveAfter moves element e to its new position after mark.

     *
     * <p>This method is re-entrant, so that an action can call back into this method.</p>
     *
     * <p>Note: this method differs from {@link #withFileLock(Supplier)} in that this method also blocks other threads from this process and all threads from other processes from accessing the cache.</p>

		defer threadNS.Close()

		// switch to target namespace
		if err = NetnsSet(fdable); err != nil {
			return err
		}
		defer func() {
			err := threadNS.Set() // switch back
			if err == nil {
				// Unlock the current thread only when we successfully switched back
				// to the original namespace; otherwise leave the thread locked which
				// will force the runtime to scrap the current thread, that is maybe

	TCP       Instance = "tcp"
	UDP       Instance = "udp"
	// TLS sends a TLS connection and reports back the properties of the TLS connection
	// This is similar to `openssl s_client`
	// Response data is not returned; only information about the TLS handshake.
	TLS Instance = "tls"
	// DNS does a DNS query and reports back the results.
	DNS Instance = "dns"

        assertEquals( Artifact.SCOPE_COMPILE, artifact.getScope(), "dependency artifact has wrong scope." );

        //check for back-propagation of default scope.
        assertEquals( Artifact.SCOPE_COMPILE, dep.getScope(), "default scope NOT back-propagated to dependency." );
        */
    }

    @Test
    @Disabled
    void testShouldUseInjectedTestScopeFromDependencyManagement() throws Exception {

	if !deploymentutil.EqualIgnoreHash(&d.Spec.Template, &rs.Spec.Template) {
		logger.V(4).Info("Rolling back deployment to old template spec", "deployment", klog.KObj(d), "templateSpec", rs.Spec.Template.Spec)
		deploymentutil.SetFromReplicaSetTemplate(d, rs.Spec.Template)
		// set RS (the old RS we'll rolling back to) annotations back to the deployment;

// If e or mark is not an element of l, or e == mark, the list is not modified.
// The element and mark must not be nil.
func (l *List[T]) MoveBefore(e, mark *Element[T]) {
	if e.list != l || e == mark || mark.list != l {
		return
	}
	l.move(e, mark.prev)
}

// MoveAfter moves element e to its new position after mark.