if !allowed {
		l.strictDupMsgs++
	}
}

func (l *Loader) NStrictDupMsgs() int { return l.strictDupMsgs }

// Number of total symbols.
func (l *Loader) NSym() int {
	return len(l.objSyms)
}

// Number of defined Go symbols.
func (l *Loader) NDef() int {
	return int(l.extStart)
}

// Number of reachable symbols.
func (l *Loader) NReachableSym() int {
	return l.attrReachable.Count()
}

	}, nil
}

func (loader *fsLoader) Load() (*kubeletconfig.KubeletConfiguration, error) {
	data, err := loader.fs.ReadFile(loader.kubeletFile)
	if err != nil {
		return nil, fmt.Errorf("failed to read kubelet config file %q, error: %v", loader.kubeletFile, err)
	}

	// no configuration is an error, some parameters are required
	if len(data) == 0 {
		return nil, fmt.Errorf("kubelet config file %q was empty", loader.kubeletFile)
	}

See the License for the specific language governing permissions and
limitations under the License.
==============================================================================*/

#include "tensorflow/cc/saved_model/loader.h"

#include <memory>
#include <string>
#include <unordered_set>
#include <utility>

#include "absl/status/status.h"
#include "absl/strings/str_cat.h"
#include "absl/strings/str_join.h"

func addDummyObjSym(t *testing.T, ldr *Loader, or *oReader, name string) Sym {
	idx := uint32(len(ldr.objSyms))
	st := loadState{l: ldr}
	return st.addSym(name, 0, or, idx, nonPkgDef, &goobj.Sym{})
}

func mkLoader() *Loader {
	er := ErrorReporter{}
	ldr := NewLoader(0, &er)
	er.ldr = ldr
	return ldr
}

func TestAddMaterializedSymbol(t *testing.T) {
	ldr := mkLoader()

      return true;
    }
  }

  private WeakReference<ClassLoader> useFrqInSeparateLoader() throws Exception {
    final ClassLoader myLoader = getClass().getClassLoader();
    URLClassLoader sepLoader = new URLClassLoader(getClassPathUrls(), myLoader.getParent());
    // sepLoader is the loader that we will use to load the parallel FinalizableReferenceQueue (FRQ)

}

func decodeReloc(ldr *loader.Loader, symIdx loader.Sym, relocs *loader.Relocs, off int32) loader.Reloc {
	for j := 0; j < relocs.Count(); j++ {
		rel := relocs.At(j)
		if rel.Off() == off {
			return rel
		}
	}
	return loader.Reloc{}
}

func decodeRelocSym(ldr *loader.Loader, symIdx loader.Sym, relocs *loader.Relocs, off int32) loader.Sym {
	return decodeReloc(ldr, symIdx, relocs, off).Sym()
}

		if err := recover(); err != nil {
			log.Printf("upload recover: %v", err)
		}
	}()
	uploader, err := newUploader(config)
	if err != nil {
		return err
	}
	defer uploader.Close()
	return uploader.Run()
}

// uploader encapsulates a single upload operation, carrying parameters and
// shared state.
type uploader struct {
	// config is used to select counters to upload.
	config        *telemetry.UploadConfig //

    def context = Mock(BuildOperationContext)
    def uploader = new ProgressLoggingExternalResourceUploader(delegate, buildOperationRunner)
    def inputStream = Mock(InputStream)
    def resource = Mock(ReadableContent)
    def location = new ExternalResourceName(new URI("https://location/thing.jar"))

    def "delegates upload to delegate uploader and logs progress"() {
        setup:
        expectPutBuildOperation(1072)

        loader.create(distribution1, loggerFactory, progressListener, params, cancellationToken)
        loader.create(distribution2, loggerFactory, progressListener, params, cancellationToken)
        loader.create(distribution1, loggerFactory, progressListener, params, cancellationToken)

        when:
        loader.close()

        then:
        1 * connection1.stop()

        expect:
        def classpath = classpathFor(actionClass)
        def loader
        try {
            loader = new VisitableURLClassLoader("test", ClassLoader.systemClassLoader.parent, classpath)
            def action = JavaReflectionUtil.newInstance(loader.loadClass(CustomAction.name))
            action.execute(null)
        } finally {
            loader?.close()
        }
    }

    private List<File> getToolingApiClassPath() {