package tx3_test

import "vendor.org/tx3"
import "testing"

var Found = tx3.Exported

func TestNop(t *testing.T) {}

-- $GOPATH/src/github.com/rsc/go-get-issue-11864/vendor/vendor.org/tx3/export_test.go --
package tx3

var Exported = true

-- $GOPATH/src/github.com/rsc/go-get-issue-11864/vendor/vendor.org/tx3/tx3.go --
package tx3

    private List<String> exports = new ArrayList<>();
    private List<String> requires = new ArrayList<>();
    private List<String> requiresTransitive = new ArrayList<>();

    ModuleInfo(String moduleName, String moduleVersion) {
        this.moduleName = moduleName;
        this.moduleVersion = moduleVersion;
    }

    public void exports(String exports) {
        this.exports.add(exports);
    }

	var tests = []struct {
		val    any     // type as a value
		_32bit uintptr // size on 32bit platforms
		_64bit uintptr // size on 64bit platforms
	}{
		{runtime.G{}, 272, 432},   // g, but exported for testing
		{runtime.Sudog{}, 56, 88}, // sudog, but exported for testing
	}

	for _, tt := range tests {
		want := tt._32bit
		if _64bit {
			want = tt._64bit
		}
		got := reflect.TypeOf(tt.val).Size()
		if want != got {

    private final CoreExports exports;

    @Inject
    public CoreExportsProvider(CoreRealm coreRealm) {
        this(new CoreExports(CoreExtensionEntry.discoverFrom(coreRealm.getRealm())));
    }

    public CoreExportsProvider(CoreExports exports) {
        this.exports = Objects.requireNonNull(exports);
    }

    public CoreExports get() {
        return exports;
    }

// license that can be found in the LICENSE file.

// Used to crash compiler in interface type equality check.
// (This test used to have problems - see #15596.)

package p

// exported interfaces

type I1 interface { // ERROR "invalid recursive type: anonymous interface refers to itself"
      F() interface{I1}
}

//
// Objects are ordered nil before non-nil, exported before
// non-exported, then by name, and finally (for non-exported
// functions) by package path.
func (a *object) less(b *object) bool {
	if a == b {
		return false
	}

	// Nil before non-nil.
	if a == nil {
		return true
	}
	if b == nil {
		return false
	}

	// Exported functions before non-exported.
	ea := isExported(a.name)

			}
			portOverrides[port.Number] = port.TargetPort
		}
	}

	var exportTo sets.Set[visibility.Instance]
	if len(serviceEntry.ExportTo) > 0 {
		exportTo = sets.NewWithLength[visibility.Instance](len(serviceEntry.ExportTo))
		for _, e := range serviceEntry.ExportTo {
			exportTo.Insert(visibility.Instance(e))
		}
	}

	var labelSelectors map[string]string

    /**
     * Returns the path to use for this project dependency.
     */
    String getPath();

    /**
     * Marks this dependency as exported.
     *
     * @return whether this dependency needs to be exported.
     * @since 2.5
     */
    boolean isExported();

    if (exported_names.empty())
      return session_initializer.emitOpError()
             << "the initializer function should be exported";

    if (exported_names.size() != 1)
      return session_initializer.emitOpError()
             << "the initializer function should have only one exported names";
  }

  return success();
}

}  // namespace tf_saved_model
}  // namespace mlir

// Transforms the given module to be suitable for export to TensorFlow GraphDef
// and then exports all functions to the given library.
Status PrepareAndExportToLibrary(mlir::ModuleOp module,
                                 FunctionLibraryDefinition* flib_def) {
  // Pass pipeline is defined here instead of leveraging the phase one export
  // pipeline because only the functional to executor dialect conversion and