#!/bin/bash
# Check if there are other tests that might call ConfigureHandle or depend on pkgHandle state
rg -n "ConfigureHandle|pkgHandle" --type=go -g '*_test.go'

# First, let's look at the ConfigureHandle implementation
fd -t f "handle_linux.go" --type=go

# Get the ConfigureHandle implementation and related global state
rg -n "ConfigureHandle|configDone|configMu" --type=go -B2 -A8 | head -100

# Check netlink_test.go setup to understand the cleanup pattern
rg -n "func.*Test|pkgHandle|configDone" handle_linux_test.go --type=go -B1 -A10

# View the beginning of netlink_test.go to see test setup
head -100 netlink_test.go

# Check if there's an init function or test setup in handle_linux_test.go
cat handle_linux_test.go

# Search for test init or setup patterns
rg -n "func init|func TestMain|func setup|t.Cleanup" --type f -B1 -A3

# Check for any test files that might initialize ConfigureHandle or set up state
rg "ConfigureHandle|configDone" --type f -l

# Check if there's a TestMain function that might handle test setup
rg "TestMain" --type f -B2 -A10

# Look at the full handle_linux_test.go to see all test functions
wc -l handle_linux_test.go && cat handle_linux_test.go

# Search for any calls to ConfigureHandle in all test files
rg "ConfigureHandle" --glob="*.go"

# Check if there are any Go test configurations like build tags or test file organization
fd . -name "*.go" -path "*_test.go" | head -20

# Check the go.mod or test runner configuration
find . -name "go.mod" -o -name "pytest.ini" -o -name "*.yaml" | grep -E "(test|ci)" | head -10

# Check the order tests run - look at test file structure
ls -la *_test.go | head -20

# Verify the visibility of configDone and configMu
rg "var config|export" handle_linux.go -B1 -A1

# Check if any test might call ConfigureHandle more than once or in sequence
rg -A20 "func Test" handle_linux_test.go

#!/bin/bash
# Check if there's any documentation about Handle thread-safety
rg -n -i "concurrent|thread.safe|goroutine" handle_linux.go
# Check if sync/atomic is used elsewhere in the codebase for similar patterns
rg -n "atomic\." --type=go

#!/bin/bash
# Find the Handle struct definition
rg -n "type Handle struct" --type=go

#!/bin/bash
# Look at the context around line 69-70 in handle_linux.go
head -n 100 handle_linux.go | tail -n 50

#!/bin/bash
# Find LinkByName and LinkByAlias function implementations
rg -n "func.*LinkByName|func.*LinkByAlias" --type=go -A 20

#!/bin/bash
# Check for any mutex or synchronization on Handle
rg -n "mutex|RWMutex|Lock|Unlock" handle_linux.go

#!/bin/bash
# Look for any Handle documentation or comments about concurrency
rg -n -B 5 "type Handle" handle_linux.go | head -n 20

#!/bin/bash
# Find where lookupByDump is written/assigned
rg -n "lookupByDump\s*=" --type=go

#!/bin/bash
# Check the complete LinkByName implementation including error handling
sed -n '2022,2055p' link_linux.go

#!/bin/bash
# Check the complete LinkByAlias implementation including error handling
sed -n '2070,2110p' link_linux.go

#!/bin/bash
# Check if there's any Handle concurrency documentation
rg -n -B 10 "type Handle struct" handle_linux.go | head -n 30

#!/bin/bash
# Check if there's any documentation saying Handle is not for concurrent use
rg -n -i "not.*concurrent|not.*thread.safe|concurrent.*not|not.*safe" --type=go | head -n 20

#!/bin/bash
# Look at package documentation in any doc.go or README-like files
find . -name "*.go" -o -name "README*" -o -name "*.md" | xargs grep -l "Handle" | head -n 5

#!/bin/bash
# Check if there are any other bool fields in Handle that are modified
rg -n "h\.[a-zA-Z]*\s*=" handle_linux.go | grep -v "h\.options\|h\.sockets"

#!/bin/bash
# Look for any concurrency/synchronization patterns in Handle methods
rg -n "Lock|Unlock|mu\." handle_linux.go