func TestPassMessagePipe(t *testing.T) { r, p := bindings.CreateMessagePipeForMojoInterface() r1, p1 := r, p handle := r1.PassMessagePipe() defer handle.Close() p1.Close() rhandle, phandle := r.PassMessagePipe(), p.PassMessagePipe() if rhandle.IsValid() || phandle.IsValid() { t.Fatal("message pipes should be invalid after PassMessagePipe() or Close()") } rhandle.Close() phandle.Close() }
// Invoke calls the mojom service based on the suffix and converts the mojom // results (a struct) to Vanadium results (a slice of *vom.RawBytes). // Note: The argptrs from Prepare are reused here. The vom bytes should have // been decoded into these argptrs, so there are actual values inside now. func (fs fakeService) Invoke(ctx *context.T, call rpc.StreamServerCall, method string, argptrs []interface{}) (results []interface{}, _ error) { // fs.suffix consists of the mojo url and the application/interface name. // The last part should be the name; everything else is the url. parts := strings.Split(fs.suffix, "/") mojourl := strings.Join(parts[:len(parts)-1], "/") // e.g., mojo:go_remote_echo_server. May be defined in a BUILD.gn file. mojoname := parts[len(parts)-1] // e.g., mojo::examples::RemoteEcho. Defined from the interface + module. // Create the generic message pipe. r is a bindings.InterfaceRequest, and // p is a bindings.InterfacePointer. r, p := bindings.CreateMessagePipeForMojoInterface() v := v23ServiceRequest{ request: r, name: mojoname, } // v is an application.ServiceRequest with mojoname // Connect to the mojourl. fs.appctx.ConnectToApplication(mojourl).ConnectToService(&v) // Then assign a new router the FakeService. // This will never conflict because each FakeService is only invoked once. fs.router = bindings.NewRouter(p.PassMessagePipe(), bindings.GetAsyncWaiter()) defer fs.Close_Proxy() ctx.Infof("Fake Service Invoke (Remote Signature: %q -- %q)", mojourl, mojoname) // Vanadium relies on type information, so we will retrieve that first. mojomInterface, desc, err := fs.callRemoteSignature(mojourl, mojoname) if err != nil { return nil, err } ctx.Infof("Fake Service Invoke Signature %v", mojomInterface) ctx.Infof("Fake Service Invoke (Remote Method: %v)", method) // With the type information, we can make the method call to the remote interface. methodResults, err := fs.callRemoteMethod(ctx, method, mojomInterface, desc, argptrs) if err != nil { ctx.Errorf("Method called failed: %v", err) return nil, err } ctx.Infof("Fake Service Invoke Results %v", methodResults) // Convert methodResult to results. results = make([]interface{}, len(methodResults)) for i := range methodResults { results[i] = &methodResults[i] } return results, nil }