}
	} else {
		association.Error = err
	}

	return association
}

func (association *Association) Unscoped() *Association {
	return &Association{
		DB:           association.DB,
		Relationship: association.Relationship,
		Error:        association.Error,
		Unscope:      true,
	}
}

func (association *Association) Find(out interface{}, conds ...interface{}) error {
	if association.Error == nil {

	return
}

// Unscoped disables the global scope of soft deletion in a query.
// By default, GORM uses soft deletion, marking records as "deleted"
// by setting a timestamp on a specific field (e.g., `deleted_at`).
// Unscoped allows queries to include records marked as deleted,
// overriding the soft deletion behavior.
// Example:
//
//	var users []User
//	db.Unscoped().Find(&users)

        String scope = "testScope";
        when(nameServiceClient.getNbtByName(host, type, scope)).thenThrow(new UnknownHostException("Host not found"));

        // Act & Assert
        assertThrows(UnknownHostException.class, () -> nameServiceClient.getNbtByName(host, type, scope));
        verify(nameServiceClient, times(1)).getNbtByName(host, type, scope);
    }

    @Test
    void testGetNbtByName_String() throws UnknownHostException {

Und die Abhängigkeitsfunktion `get_current_active_user` kann auch Unterabhängigkeiten deklarieren, nicht nur mit `Depends`, sondern auch mit `Security`. Ihre eigene Unterabhängigkeitsfunktion (`get_current_user`) und weitere Scope-Anforderungen deklarierend.

In diesem Fall erfordert sie den Scope `me` (sie könnte mehr als einen Scope erfordern).

/// note | Hinweis

            return addDependency(groupId, artifactId, version, scope, (Exclusion) null);
        }

        public ProjectBuilder addDependency(
                String groupId, String artifactId, String version, String scope, Exclusion exclusion) {
            return addDependency(groupId, artifactId, version, scope, null, exclusion);
        }

			<version>2.2</version>
			<scope>test</scope>
		</dependency>
		<dependency>
			<groupId>org.mockito</groupId>
			<artifactId>mockito-core</artifactId>
			<version>5.11.0</version>
			<scope>test</scope>
		</dependency>
		<dependency>
			<groupId>org.testcontainers</groupId>
			<artifactId>testcontainers</artifactId>
			<version>1.21.3</version>
			<scope>test</scope>
		</dependency>
		<dependency>

        byte[] dst = new byte[100];

        int length = name.writeWireFormat(dst, 0);

        // Scope should start at position 33 with a length byte (not '.')
        // The first byte after encoding would be the length of "scope"
        assertEquals(5, dst[33]); // Length of "scope"

        // Verify total length includes scope

				}
			} else {
				tx := db.Table("").Session(&gorm.Session{Context: db.Statement.Context, SkipHooks: db.Statement.SkipHooks})
				tx.Statement.ReflectValue = db.Statement.ReflectValue
				tx.Statement.Unscoped = db.Statement.Unscoped
				if err := preload(tx, rel, append(preloads[name], associationsConds...), preloadMap[name]); err != nil {
					return err
				}
			}
		} else {

    }

    @Override
    public void setDependencyTrail(List<String> dependencyTrail) {
        this.dependencyTrail = dependencyTrail;
    }

    @Override
    public void setScope(String scope) {
        this.scope = scope;
    }

    @Override
    public VersionRange getVersionRange() {
        return versionRange;
    }

    @Override
    public void setVersionRange(VersionRange versionRange) {

    /**
     * Gets the cache scope (ALL or IMMEDIATE_CHILDREN)
     * @return the cache scope
     */
    public DirectoryCacheScope getScope() {
        return scope;
    }

    /**
     * Sets the cache scope for this directory cache
     * @param scope the cache scope to set
     */
    public void setScope(DirectoryCacheScope scope) {
        this.scope = scope;
    }

    /**