Code Quality and Defensive Programming Questions

package lru

import (
	"container/list"
	"errors"
	"sync"
)

// Cache is a concurrency-safe LRU cache.
type Cache struct {
	mu       sync.RWMutex
	capacity int
	ll       *list.List
	table    map[string]*list.Element
}

type entry struct {
	key   string
	value interface{}
}

// New creates an LRU cache with positive capacity.
func New(capacity int) (*Cache, error) {
	if capacity <= 0 {
		return nil, errors.New("capacity must be > 0")
	}
	return &Cache{
		capacity: capacity,
		ll:       list.New(),
		table:    make(map[string]*list.Element, capacity),
	}, nil
}

// Get returns value and whether it existed. Access updates recency.
func (c *Cache) Get(key string) (interface{}, bool) {
	if key == "" {
		return nil, false
	}
	c.mu.Lock()
	defer c.mu.Unlock()

	if ele, ok := c.table[key]; ok {
		c.ll.MoveToFront(ele)
		return ele.Value.(*entry).value, true
	}
	return nil, false
}

// Put inserts or updates the key. Evicts least-recently-used when capacity exceeded.
func (c *Cache) Put(key string, value interface{}) {
	if key == "" {
		return // reject empty keys
	}
	c.mu.Lock()
	defer c.mu.Unlock()

	if ele, ok := c.table[key]; ok {
		ele.Value.(*entry).value = value
		c.ll.MoveToFront(ele)
		return
	}

	ele := c.ll.PushFront(&entry{key: key, value: value})
	c.table[key] = ele

	if c.ll.Len() > c.capacity {
		// evict LRU (back)
		ev := c.ll.Back()
		if ev != nil {
			c.ll.Remove(ev)
			delete(c.table, ev.Value.(*entry).key)
		}
	}
}

// Len returns current size.
func (c *Cache) Len() int {
	c.mu.RLock()
	defer c.mu.RUnlock()
	return c.ll.Len()
}

package lru_test

import (
	"testing"

	"your/module/path/lru"
)

func TestNewZeroCapacity(t *testing.T) {
	if _, err := lru.New(0); err == nil {
		t.Fatal("expected error for zero capacity")
	}
}

func TestEmptyKeyRejected(t *testing.T) {
	c, _ := lru.New(2)
	c.Put("", "x")
	if c.Len() != 0 {
		t.Fatalf("expected len 0, got %d", c.Len())
	}
	if v, ok := c.Get(""); ok || v != nil {
		t.Fatal("expected no value for empty key")
	}
}

func TestEvictionOrder(t *testing.T) {
	c, _ := lru.New(2)
	c.Put("a", 1)
	c.Put("b", 2)
	// access a to make b the LRU
	if _, ok := c.Get("a"); !ok {
		t.Fatal("expected a to exist")
	}
	c.Put("c", 3) // should evict b
	if _, ok := c.Get("b"); ok {
		t.Fatal("expected b to be evicted")
	}
	if v, ok := c.Get("a"); !ok || v.(int) != 1 {
		t.Fatal("expected a still present")
	}
	if v, ok := c.Get("c"); !ok || v.(int) != 3 {
		t.Fatal("expected c present")
	}
}

def safe_divide(a, b):
    """
    Divide a by b and return a float.
    Raises ValueError for None, non-numeric, or zero divisor.
    """
    # Reject None explicitly
    if a is None or b is None:
        raise ValueError("Inputs must not be None")

    # Accept ints and floats only (explicit type check to avoid surprising behavior)
    if not isinstance(a, (int, float)) or not isinstance(b, (int, float)):
        raise ValueError("Inputs must be numeric (int or float)")

    # Prevent division by zero (handles 0 and 0.0)
    if b == 0:
        raise ValueError("Division by zero")

    return float(a) / float(b)

f, err := os.Open(path)
if err != nil { return err }
defer f.Close()
// use f

try (InputStream in = Files.newInputStream(path)) {
  // use in
} // auto-close

ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
defer cancel()
jobs := make(chan Job)
for i := 0; i < poolSize; i++ {
  go func() {
    for j := range jobs {
      select {
      case <-ctx.Done(): return
      default: process(j)
      }
    }
  }()
}