Boolean — Find the Bug¶

package main

import "fmt"

type User struct {
    Age int
}

func main() {
    var u *User // nil pointer

    // This code panics
    if u.Age > 18 && u != nil {
        fmt.Println("Adult user")
    }
}

package main

import "fmt"

func isUserActive(id int) bool {
    activeUsers := map[int]bool{1: true, 2: true, 3: false}
    return activeUsers[id]
}

func main() {
    // Should print users that are NOT active
    for i := 1; i <= 3; i++ {
        if isUserActive(i) == false {
            fmt.Printf("Inactive user: %d\n", i)
        }
    }

    // Bug: what about user 4? (not in map)
    fmt.Printf("User 4 active: %v\n", isUserActive(4) == true)
    // Expected: false (not in map = not active)
    // Actual: false — but this masks a logic issue below

    // The real bug: this condition is always wrong
    users := []int{1, 2, 3, 4, 5}
    activeCount := 0
    for _, id := range users {
        if isUserActive(id) == true == true { // BUG: double == true
            activeCount++
        }
    }
    fmt.Println("Active count:", activeCount) // Expected: 2, Actual: 2 (but fragile code)
}

package main

import "fmt"

func getStatus() int {
    return 1 // 1 means active
}

func main() {
    status := getStatus()

    // BUG: This doesn't compile in Go
    if status {
        fmt.Println("Active")
    }

    count := 5
    // BUG: This doesn't compile either
    for count {
        fmt.Println("running")
        count--
    }
}

package main

import "fmt"

func main() {
    isAdmin := false
    isOwner := true
    isActive := true

    // Intended: (isAdmin || isOwner) && isActive
    // Actual evaluation: isAdmin || (isOwner && isActive)
    if isAdmin || isOwner && isActive {
        fmt.Println("Access granted")
    } else {
        fmt.Println("Access denied")
    }

    // Test case that reveals the bug:
    isAdmin2 := false
    isOwner2 := false
    isActive2 := true

    // With intended logic: (false || false) && true = false
    // With actual logic:   false || (false && true) = false
    // Both give same result here — but what about:

    isAdmin3 := false
    isOwner3 := true
    isActive3 := false

    // Intended: (false || true) && false = false (owner but inactive)
    // Actual:   false || (true && false)  = false (same result — hidden bug!)

    // This case REVEALS the bug:
    isAdmin4 := true
    isOwner4 := false
    isActive4 := false

    // Intended: (true || false) && false = FALSE (admin but inactive)
    // Actual:   true || (false && false) = TRUE  (BUG: inactive admin gets access!)
    if isAdmin4 || isOwner4 && isActive4 {
        fmt.Println("Bug: inactive admin got access!")
    }

    _ = isAdmin2
    _ = isOwner2
    _ = isActive2
    _ = isAdmin3
    _ = isOwner3
    _ = isActive3
}

package main

import (
    "fmt"
    "time"
)

var isReady bool // SHARED: data race!

func producer() {
    time.Sleep(100 * time.Millisecond)
    isReady = true // WRITE: no synchronization
}

func consumer() {
    for !isReady { // READ: no synchronization
        time.Sleep(10 * time.Millisecond)
    }
    fmt.Println("Ready!")
}

func main() {
    go producer()
    consumer()
}

package main

import "fmt"

type User struct {
    Name      string
    IsBlocked bool
    IsBanned  bool
}

func canSendMessage(user User) bool {
    // BUG: double negative — confusing and error-prone
    isNotBlocked := !user.IsBlocked
    isNotBanned := !user.IsBanned
    return !(!isNotBlocked || !isNotBanned)
}

func main() {
    alice := User{Name: "Alice", IsBlocked: false, IsBanned: false}
    bob := User{Name: "Bob", IsBlocked: true, IsBanned: false}
    charlie := User{Name: "Charlie", IsBlocked: false, IsBanned: true}

    fmt.Println(alice.Name, "can send:", canSendMessage(alice))   // true
    fmt.Println(bob.Name, "can send:", canSendMessage(bob))       // false
    fmt.Println(charlie.Name, "can send:", canSendMessage(charlie)) // false
}

package main

import "fmt"

type ServerConfig struct {
    Host     string
    Port     int
    DisableTLS bool // zero value = false = TLS is NOT disabled = TLS enabled
}

func NewDefaultConfig() ServerConfig {
    return ServerConfig{
        Host: "localhost",
        Port: 8080,
        // DisableTLS not set — zero value = false
        // This means TLS is ENABLED by default — intended? Maybe.
    }
}

func startServer(cfg ServerConfig) {
    if cfg.DisableTLS {
        fmt.Println("Starting HTTP server (TLS disabled)")
    } else {
        fmt.Println("Starting HTTPS server (TLS enabled)")
    }
}

// The BUG: developer adds a new config and forgets to set it
func main() {
    // Scenario 1: production (wants TLS enabled)
    prodConfig := NewDefaultConfig()
    startServer(prodConfig) // Correct: HTTPS

    // Scenario 2: developer forgets to explicitly disable TLS in test
    testConfig := ServerConfig{Host: "localhost", Port: 9090}
    startServer(testConfig) // BUG: TLS enabled in test (developer expected HTTP!)
    // Developer intended: DisableAuth: true — but forgot to set it

    // Scenario 3: field renamed by someone else
    // DisableTLS renamed to EnableTLS without updating all callers
    // Now all callers that didn't set it have EnableTLS=false (disabled!)
    // This is the "zero value trap" with negative-named booleans
}

package main

import "fmt"

var processedCount int

func validateAndCount(item string) bool {
    processedCount++ // side effect: increment counter
    return len(item) > 0
}

func processItems(items []string) int {
    // BUG: short-circuit means validateAndCount may not be called for all items
    for _, item := range items {
        if false && validateAndCount(item) { // always false — validateAndCount NEVER called
            fmt.Println("Processing:", item)
        }
    }
    return processedCount
}

func main() {
    items := []string{"apple", "banana", "cherry"}
    count := processItems(items)
    fmt.Printf("Processed %d items (expected 3)\n", count) // 0, not 3!
}

package main

import (
    "fmt"
)

func riskyCheck(s string) bool {
    fmt.Printf("  checking: '%s'\n", s)
    if s == "panic" {
        panic("deliberate panic!")
    }
    return len(s) > 0
}

func main() {
    // Using & instead of && — no short-circuit, both sides always evaluated
    // This won't compile for bool — but developers sometimes make this mistake
    // conceptually, thinking & and && are interchangeable

    // Simulated scenario: using functions in conditions
    a := len("hello") > 0  // evaluates to true
    b := len("") > 0       // evaluates to false

    // BUG: using single & (bitwise) won't compile on bool:
    // result := a & b  // compile error

    // But in C, you could do: if (getUser() & validateUser())
    // In Go, the correct form is:
    result := a && b  // logical AND with short-circuit
    fmt.Println("Result:", result)

    // The real bug manifests when developers call functions:
    // if expensiveQuery() & validateResult()  -- this is WRONG in Go
    // It would try bitwise AND on bool, which doesn't compile

    // What they should write:
    if riskyCheck("hello") && riskyCheck("world") {
        fmt.Println("Both valid")
    }

    // This would panic without short-circuit if first returns false:
    fmt.Println("Testing short-circuit safety:")
    safeStr := ""
    if len(safeStr) > 0 && riskyCheck(safeStr) {
        fmt.Println("Won't reach here")
    }
    fmt.Println("No panic!")
}

package main

import "fmt"

type Order struct {
    ID          int
    IsPending   bool
    IsPaid      bool
    IsShipped   bool
    IsDelivered bool
    IsCancelled bool
}

func (o *Order) Pay() {
    o.IsPaid = true
    // BUG: forgot to set IsPending = false
}

func (o *Order) Ship() {
    o.IsShipped = true
    // BUG: didn't check if IsPaid first
    // BUG: didn't set IsPending = false
}

func (o *Order) Cancel() {
    o.IsCancelled = true
    // BUG: didn't set other flags to false
    // Now IsPaid=true AND IsCancelled=true — invalid state!
}

func (o Order) Status() string {
    if o.IsCancelled {
        return "cancelled"
    }
    if o.IsDelivered {
        return "delivered"
    }
    if o.IsShipped {
        return "shipped"
    }
    if o.IsPaid {
        return "paid"
    }
    return "pending"
}

func main() {
    order := Order{ID: 1, IsPending: true}

    order.Pay()
    order.Ship() // shipped without checking IsPaid!
    order.Cancel()

    fmt.Printf("Status: %s\n", order.Status())
    // Status: cancelled — but order.IsPaid=true AND order.IsShipped=true AND order.IsCancelled=true
    // This is an INVALID STATE

    fmt.Printf("Paid: %v, Shipped: %v, Cancelled: %v\n",
        order.IsPaid, order.IsShipped, order.IsCancelled)
    // Paid: true, Shipped: true, Cancelled: true — IMPOSSIBLE in real life
}

package main

import "fmt"

type AccessControl struct {
    Permissions map[string]bool // BUG: not initialized
}

func NewAccessControl() AccessControl {
    return AccessControl{} // BUG: map is nil!
}

func (ac *AccessControl) Grant(permission string) {
    ac.Permissions[permission] = true // PANIC: assignment to nil map
}

func (ac *AccessControl) Has(permission string) bool {
    return ac.Permissions[permission] // OK to read from nil map (returns false)
}

func main() {
    ac := NewAccessControl()

    // Reading from nil map is OK:
    fmt.Println(ac.Has("read")) // false (no panic)

    // Writing to nil map: PANIC
    ac.Grant("read") // panic: assignment to entry in nil map
}