if e != nil {
		return
	}
	syscall.Write(f, []byte("hangup"))
	syscall.Close(f)
}

// Wait for the I/O operation to complete.
func (aio *asyncIO) Wait() (int, error) {
	res := <-aio.res
	return res.n, res.err
}

// The following functions, provided by the runtime, are used to
// ignore and unignore the "hangup" signal received by the process.
func runtime_ignoreHangup()

					continue
				}
				if _, f := res[fromKey]; !f {
					res[fromKey] = map[Reference]*Grants{}
				}
				if _, f := res[fromKey][toKey]; !f {
					res[fromKey][toKey] = &Grants{
						AllowedNames: sets.New[string](),
					}
				}
				if to.Name != nil {
					res[fromKey][toKey].AllowedNames.Insert(string(*to.Name))
				} else {
					res[fromKey][toKey].AllowAll = true
				}
			}
		}

func find(src, s string, n int) []int {
	var res []int
	if s != "" && n != 0 {
		// find at most n occurrences of s in src
		for i := -1; n < 0 || len(res) < n; {
			j := strings.Index(src[i+1:], s)
			if j < 0 {
				break
			}
			i += j + 1
			res = append(res, i)
		}
	}
	return res
}

func testLookup(t *testing.T, tc *testCase, x *Index, s string, n int) {
	res := x.Lookup([]byte(s), n)

            MetadataGraph res = new MetadataGraph(vertices.size());
            res.setVersionedVertices(false);
            res.setScopedVertices(false);

            MetadataGraphVertex resEntry = res.addVertex(entry.getMd());
            res.setEntry(resEntry);

            res.setScope(requestedScope);

            for (MetadataGraphVertex v : vertices) {

		res = append(res, nestedValueValidationToStructural(&subSchema))
	}
	return res
}

func (s *Structural) OneOf() []common.Schema {
	var res []common.Schema
	for _, subSchema := range s.Structural.ValueValidation.OneOf {
		subSchema := subSchema
		res = append(res, nestedValueValidationToStructural(&subSchema))
	}
	return res
}

func (s *Structural) Not() common.Schema {

					Name:      resource.LocalName(cfg.Name),
					Namespace: resource.Namespace(cfg.Namespace),
				}, id,
			}
			if res, ok := i.found[k]; ok {
				if !broken && !fn(res) {
					broken = true
				}
				cache[k] = res
				continue
			}
			res, err := cfgToInstance(cfg, col, colschema, id)
			if err != nil {
				// TODO: demote this log before merging
				log.Error(err)

	))
	defer ts.Close()

	// No timeouts
	ctx = context.Background()
	sendResponse <- resp
	res, err := http.Get(ts.URL)
	if err != nil {
		t.Fatal(err)
	}
	if res.StatusCode != http.StatusOK {
		t.Errorf("got res.StatusCode %d; expected %d", res.StatusCode, http.StatusOK)
	}
	body, _ := ioutil.ReadAll(res.Body)
	if string(body) != resp {
		t.Errorf("got body %q; expected %q", string(body), resp)
	}

	if err == nil && exists {
		res, err := c.Delete(
			index,
			key,
			c.Delete.WithContext(ctx),
		)
		if err != nil {
			return err
		}
		defer xhttp.DrainBody(res.Body)
		if res.IsError() {
			return fmt.Errorf("Delete err: %s", res.String())
		}
		return nil
	}
	return err
}

			t.Error("expected non-nil Request.Response")
		}
		return ErrUseLastResponse
	}
	res, err := c.Get(ts.URL)
	if err != nil {
		t.Fatal(err)
	}
	if res.StatusCode != StatusFound {
		t.Errorf("status = %d; want %d", res.StatusCode, StatusFound)
	}
	defer res.Body.Close()
	slurp, err := io.ReadAll(res.Body)
	if err != nil {
		t.Fatal(err)
	}
	if string(slurp) != body {

		t.Run(tc.reqPath, func(t *testing.T) {
			res, err := c.Get(ts.URL + tc.reqPath)
			if err != nil {
				t.Fatal(err)
			}
			res.Body.Close()
			if tc.path == "" {
				if res.StatusCode != StatusNotFound {
					t.Errorf("got %q, want 404 Not Found", res.Status)
				}
				return
			}
			if res.StatusCode != StatusOK {
				t.Fatalf("got %q, want 200 OK", res.Status)
			}