if recover() == nil {
			t.Fatalf("unlock of unlocked RWMutex did not panic")
		}
	}()
	mu := NewDRWMutex(ds, "test")
	mu.Unlock(t.Context())
}

// Borrowed from rwmutex_test.go
func TestUnlockPanic2(t *testing.T) {
	mu := NewDRWMutex(ds, "test-unlock-panic-2")
	defer func() {
		if recover() == nil {
			t.Fatalf("unlock of unlocked RWMutex did not panic")
		}

</QueueConfiguration>`)
	queue3 := &Queue{}
	if err := xml.Unmarshal(data, queue3); err != nil {
		panic(err)
	}

	targetList1 := NewTargetList(t.Context())

	targetList2 := NewTargetList(t.Context())
	if err := targetList2.Add(&ExampleTarget{TargetID{"1", "webhook"}, false, false}); err != nil {
		panic(err)
	}

	testCases := []struct {
		queue      *Queue
		region     string
		targetList *TargetList

		panic(err)
	}

	targetListCase3 := NewTargetList(t.Context())
	if err := targetListCase3.Add(&ExampleTarget{TargetID{"3", "testcase"}, false, false}); err != nil {
		panic(err)
	}
	if err := targetListCase3.Add(&ExampleTarget{TargetID{"1", "webhook"}, false, false}); err != nil {
		panic(err)
	}

	testCases := []struct {
		targetList     *TargetList

	ctx := t.Context()
	lrwm := NewLRWMutex()

	if !lrwm.GetRLock(ctx, "", "object1", time.Second) {
		panic("Failed to acquire read lock")
	}
	// fmt.Println("1st read lock acquired, waiting...")

	if !lrwm.GetRLock(ctx, "", "object1", time.Second) {
		panic("Failed to acquire read lock")
	}
	// fmt.Println("2nd read lock acquired, waiting...")

	go func() {
		time.Sleep(2 * time.Second)

	}
	logJSON, err := json.Marshal(&log.Entry{
		Level:   FatalKind,
		Message: message,
		Time:    time.Now().UTC(),
		Trace:   &log.Trace{Message: message, Source: []string{getSource(6)}},
	})
	if err != nil {
		panic(err)
	}
	fmt.Fprintln(Output, string(logJSON))
	ExitFunc(1)
}

func (f fatalMsg) quiet(msg string, args ...any) {
	f.pretty(msg, args...)
}

var (
	logTag      = "FATAL"

// byte arrays sized based on width.
func NewBytePoolCap(maxSize uint64, width int, capwidth int) (bp *BytePoolCap) {
	if capwidth <= 0 {
		panic("total buffer capacity must be provided")
	}
	if capwidth < 64 {
		panic("buffer capped with smaller than 64 bytes is not supported")
	}
	if width > capwidth {
		panic("minimum buffer length cannot be > capacity of the buffer")
	}
	return &BytePoolCap{
		c:    make(chan []byte, maxSize),

// as we only guarantee a lookback buffer size of one, any subsequent calls to back()
// before calling next() may panic
func (s *scanner) back() {
	if s.ipos <= 0 {
		panic("back buffer exhausted")
	}
	s.ipos--
	s.pos--

	desc, ok := m.descriptors[name]
	if !ok {
		panic(fmt.Sprintf("metric has no description: %s", name))
	}

	if len(labels)%2 != 0 {
		panic("labels must be a list of ordered key-value pairs")
	}

	validLabels := desc.getLabelSet()
	labelMap := make(map[string]string, len(labels)/2)
	for i := 0; i < len(labels); i += 2 {
		if _, ok := validLabels[labels[i]]; !ok {

package tests_test

import (
	"testing"

	"gorm.io/gorm"
)

type Man struct {
	ID     int
	Age    int
	Name   string
	Detail string
}

// Panic-safe BeforeUpdate hook that checks for Changed("age")
func (m *Man) BeforeUpdate(tx *gorm.DB) (err error) {
	if !tx.Statement.Changed("age") {
		return nil
	}
	return nil
}

func TestSubModel(t *testing.T) {
	man := Man{Age: 18, Name: "random-name"}

func toString(val any) string {
	switch v := val.(type) {
	case string:
		return v
	default:
		return ""
	}
}

// toLowerString - safely convert interface to lower string
func toLowerString(val any) string {
	return strings.ToLower(toString(val))
}

// toInteger _ Safely convert interface to integer without causing panic.
func toInteger(val any) (int64, error) {