From 62c688973641bcab202edec99850d28cd73598e1 Mon Sep 17 00:00:00 2001
From: Joshua MacDonald <josh.macdonald@gmail.com>
Date: Thu, 10 Oct 2024 10:33:12 -0700
Subject: [PATCH] new test

---
 internal/global/alt_sdk_test.go | 166 ++++++++++++++++++++++++++++++++
 1 file changed, 166 insertions(+)
 create mode 100644 internal/global/alt_sdk_test.go

diff --git a/internal/global/alt_sdk_test.go b/internal/global/alt_sdk_test.go
new file mode 100644
index 00000000000..91e9e7697d9
--- /dev/null
+++ b/internal/global/alt_sdk_test.go
@@ -0,0 +1,166 @@
+// Copyright The OpenTelemetry Authors
+// SPDX-License-Identifier: Apache-2.0
+
+package global // import "go.opentelemetry.io/otel/internal/global"
+
+import (
+	"context"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+
+	"go.opentelemetry.io/otel/metric"
+	"go.opentelemetry.io/otel/metric/embedded"
+)
+
+type altMeterProvider struct {
+	t      *testing.T
+	meters []*altMeter
+	embedded.MeterProvider
+}
+
+var _ metric.MeterProvider = &altMeterProvider{}
+
+func (amp *altMeterProvider) Meter(name string, opts ...metric.MeterOption) metric.Meter {
+	am := &altMeter{
+		provider: amp,
+	}
+	amp.meters = append(amp.meters, am)
+	return am
+}
+
+type altMeter struct {
+	provider *altMeterProvider
+	cbs      []metric.Callback
+	embedded.Meter
+}
+
+var _ metric.Meter = &altMeter{}
+
+type testAsyncCounter struct {
+	meter *altMeter
+	embedded.Int64ObservableCounter
+	metric.Int64Observable
+}
+
+var _ metric.Int64ObservableCounter = &testAsyncCounter{}
+
+type altRegistration struct {
+	cb metric.Callback
+	embedded.Registration
+}
+
+type altObserver struct {
+	t *testing.T
+	embedded.Observer
+}
+
+func (*altRegistration) Unregister() error {
+	return nil
+}
+
+func (am *altMeter) Int64Counter(name string, options ...metric.Int64CounterOption) (metric.Int64Counter, error) {
+	return nil, nil
+}
+func (am *altMeter) Int64UpDownCounter(name string, options ...metric.Int64UpDownCounterOption) (metric.Int64UpDownCounter, error) {
+	return nil, nil
+}
+func (am *altMeter) Int64Histogram(name string, options ...metric.Int64HistogramOption) (metric.Int64Histogram, error) {
+	return nil, nil
+}
+
+func (am *altMeter) Int64Gauge(name string, options ...metric.Int64GaugeOption) (metric.Int64Gauge, error) {
+	return nil, nil
+}
+
+func (am *altMeter) Int64ObservableCounter(name string, options ...metric.Int64ObservableCounterOption) (metric.Int64ObservableCounter, error) {
+	return &testAsyncCounter{
+		meter: am,
+	}, nil
+}
+
+func (am *altMeter) Int64ObservableUpDownCounter(name string, options ...metric.Int64ObservableUpDownCounterOption) (metric.Int64ObservableUpDownCounter, error) {
+	return nil, nil
+}
+
+func (am *altMeter) Int64ObservableGauge(name string, options ...metric.Int64ObservableGaugeOption) (metric.Int64ObservableGauge, error) {
+	return nil, nil
+}
+func (am *altMeter) Float64Counter(name string, options ...metric.Float64CounterOption) (metric.Float64Counter, error) {
+	return nil, nil
+}
+func (am *altMeter) Float64UpDownCounter(name string, options ...metric.Float64UpDownCounterOption) (metric.Float64UpDownCounter, error) {
+	return nil, nil
+}
+func (am *altMeter) Float64Histogram(name string, options ...metric.Float64HistogramOption) (metric.Float64Histogram, error) {
+	return nil, nil
+}
+func (am *altMeter) Float64Gauge(name string, options ...metric.Float64GaugeOption) (metric.Float64Gauge, error) {
+	return nil, nil
+}
+func (am *altMeter) Float64ObservableCounter(name string, options ...metric.Float64ObservableCounterOption) (metric.Float64ObservableCounter, error) {
+	return nil, nil
+}
+func (am *altMeter) Float64ObservableUpDownCounter(name string, options ...metric.Float64ObservableUpDownCounterOption) (metric.Float64ObservableUpDownCounter, error) {
+	return nil, nil
+}
+func (am *altMeter) Float64ObservableGauge(name string, options ...metric.Float64ObservableGaugeOption) (metric.Float64ObservableGauge, error) {
+	// Note: The global delegation also breaks when we return nil in one of these!
+	return nil, nil
+}
+
+func (am *altMeter) RegisterCallback(f metric.Callback, instruments ...metric.Observable) (metric.Registration, error) {
+	for _, inst := range instruments {
+		switch inst.(type) {
+		case *testAsyncCounter:
+			// OK!
+		default:
+			am.provider.t.Errorf("unexpected type %T", inst)
+		}
+	}
+	am.cbs = append(am.cbs, f)
+	return &altRegistration{cb: f}, nil
+}
+
+func (ao *altObserver) ObserveFloat64(inst metric.Float64Observable, _ float64, _ ...metric.ObserveOption) {
+	ao.observe(inst)
+}
+
+func (ao *altObserver) ObserveInt64(inst metric.Int64Observable, _ int64, _ ...metric.ObserveOption) {
+	ao.observe(inst)
+}
+
+func (ao *altObserver) observe(inst any) {
+	switch inst.(type) {
+	case *testAsyncCounter:
+		// OK!
+	default:
+		ao.t.Errorf("unexpected type %T", inst)
+	}
+}
+
+func TestMeterDelegation(t *testing.T) {
+	ResetForTest(t)
+
+	amp := &altMeterProvider{t: t}
+
+	gm := MeterProvider().Meter("test")
+	ai, err := gm.Int64ObservableCounter("test_counter")
+	require.NoError(t, err)
+
+	_, err = gm.RegisterCallback(func(_ context.Context, obs metric.Observer) error {
+		obs.ObserveInt64(ai, 10)
+		return nil
+	}, ai)
+	require.NoError(t, err)
+
+	SetMeterProvider(amp)
+
+	ctx := context.Background()
+	ao := &altObserver{t: t}
+	for _, meter := range amp.meters {
+		for _, cb := range meter.cbs {
+			cb(ctx, ao)
+		}
+	}
+}