// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
// Author: ******@****.*** (Keith Ray)
//
// Google Test filepath utilities
//

//        `ctx` must outlive the returned TF_SavedModel pointer.
//  status - Set to OK on success and an appropriate error on failure.
// Returns:
//  If status is not OK, returns nullptr. Otherwise, returns a newly created
//  TF_SavedModel instance. It must be deleted by calling TF_DeleteSavedModel.
TF_CAPI_EXPORT extern TF_SavedModel* TF_LoadSavedModel(const char* dirname,

)

// Combine combines the DefinitionsSchemaResolver with a secondary schema resolver.
// The resulting schema resolver uses the DefinitionsSchemaResolver for a GVK that DefinitionsSchemaResolver knows,
// and the secondary otherwise.
func (d *DefinitionsSchemaResolver) Combine(secondary SchemaResolver) SchemaResolver {
	return &combinedSchemaResolver{definitions: d, secondary: secondary}
}

type combinedSchemaResolver struct {

        deletedFiles == [file, parent, grandparent]
    }

    def "does not delete non-empty parent directories"() {
        given:
        def grandparent = cacheDir.createDir("a")
        def anotherFile = grandparent.createFile("anotherfile")
        def parent = grandparent.createDir("b")
        def file = parent.createFile("somefile")

        when:
        cleanupAction(finder([file]), { true })

        expect:
        visit(visitor,
                file(new RelativePath(true, "rootfile.txt"), new File(destDir, "rootfile.txt")),
                file(new RelativePath(true, "subdir", "anotherfile.txt"), new File(destDir, "subdir/anotherfile.txt"))
        )
    }

    private FileCopyDetailsInternal file(final RelativePath relativePath, final File targetFile) {
        final FileCopyDetailsInternal details = Mock(FileCopyDetailsInternal)

			if i := c.GetKey(Key[T](k)); i != nil {
				list = append(list, *i)
			}
		}
	} else if d.filter.listFromIndex != nil {
		// Otherwise from an index; fetch from there. Often this is a list of a namespace
		list = d.filter.listFromIndex().([]T)
	} else {
		// Otherwise get everything
		list = c.List()
	}
	list = slices.FilterInPlace(list, func(i T) bool {
		o := c.augment(i)
		return d.filter.Matches(o, true)
	})

	// In the presence of unfinished cyclic declarations, Unalias
	// would otherwise latch the invalid value (#66704).
	// TODO(adonovan): rethink, along with checker.typeDecl's use
	// of Invalid to mark unfinished aliases.
	if t != Typ[Invalid] {
		a0.actual = t
	}

	return t
}

// asNamed returns t as *Named if that is t's
// actual type. It returns nil otherwise.
func asNamed(t Type) *Named {
	n, _ := Unalias(t).(*Named)

     *
     * @return true if the task for this operation holds the lock for this resource.
     */
    boolean isLockedByCurrentThread();

    /**
     * Attempt to lock this resource, if not already.  Does not block.
     *
     * @return true if resource is now locked, false otherwise.
     */
    boolean tryLock();

    /**

// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
// Author: ******@****.*** (Keith Ray)
//
// Google Test filepath utilities
//

     * @return the model, otherwise {@code null}
     */
    Model getRawModel(Path from, Path pomFile);

    /**
     * Get the model from the reactor based on the groupId and artifactId when resolving reactor dependencies.
     *
     * @param from    the requiring model
     * @param groupId    the groupId
     * @param artifactId the artifactId
     * @return the model, otherwise {@code null}