package runtimebench

import (
	"context"
	"errors"
	"net/http"
	"net/http/httptest"
	"testing"
	"time"
)

type lookupError struct{}

func (*lookupError) Error() string { return "lookup" }

func TestOwnership(t *testing.T) {
	var p *lookupError
	var err error = p
	if err == nil {
		t.Fatal("interface lost dynamic type")
	}
	page := make([]byte, 4, 64)
	head := page[:2]
	head = append(head, 9)
	if page[2] != 9 {
		t.Fatal("expected shared storage")
	}
	isolated := page[:2:2]
	isolated = append(isolated, 7)
	if page[2] != 9 || isolated[2] != 7 {
		t.Fatal("unexpected alias")
	}
}
func TestCancelReachesUpstream(t *testing.T) {
	entered, stopped := make(chan struct{}), make(chan struct{})
	upstream := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		close(entered)
		<-r.Context().Done()
		close(stopped)
	}))
	defer upstream.Close()
	parent, cancel := context.WithCancel(context.Background())
	defer cancel()
	ctx, stop := context.WithTimeout(parent, 2*time.Second)
	defer stop()
	req, err := http.NewRequestWithContext(ctx, "GET", upstream.URL, nil)
	if err != nil {
		t.Fatal(err)
	}
	done := make(chan error, 1)
	go func() {
		resp, e := http.DefaultClient.Do(req)
		if resp != nil {
			resp.Body.Close()
		}
		done <- e
	}()
	select {
	case <-entered:
	case <-ctx.Done():
		t.Fatal("server not reached")
	}
	cancel()
	if !errors.Is(<-done, context.Canceled) {
		t.Fatal("lost cancellation")
	}
	select {
	case <-stopped:
	case <-time.After(time.Second):
		t.Fatal("upstream still running")
	}
}