if (user.status == 'active' and user.status == 'inactive'):
    send_alert("Contradictory status detected!") # This line will never execute

if (isActive && !isActive) {
    sendNotification();
}

def process_age(age):
    if age > 0 and age < 0:  # Impossible condition
        return "valid"
    return "invalid"

def validate_input(data):
    if data is None:
        return False
        print("Data is None")  # Unreachable
    
    if len(data) == 0:
        return False
    else:
        return True
        cleanup_data(data)  # Unreachable

for i in range(10):
    # AI's attempt to optimize or add an unrelated feature
    # that inadvertently resets or modifies 'i' in a way that prevents normal iteration
    if some_condition:
        i = 0 # This could lead to an infinite loop or drastically alter intended sums
    total += data[i]

def calculate_total_with_tax(price):
    tax = price * 0.1
    price_with_tax = price + tax
    final_price = calculate_total_with_tax(price_with_tax)  # Infinite recursion
    return final_price

def update_user_status(user):
    user.is_active = True
    if user.subscription_expired():
        # Hallucination: AI correctly identifies the 'expired' condition
        # but assigns the *same* value, not the contradictory one.
        user.is_active = True  # Should be False
    return user

public Cart addItem(Item item) {
    this.items.add(item);
    this.totalPrice += item.getPrice();
    this.isEmpty = false;

    if (this.items.size() > 0) {
        // Redundant and potentially contradictory if logic was more complex
        this.isEmpty = false;
    } else {
        // This branch is now impossible because we just added an item
        this.isEmpty = true;
    }
    return this;
}

def get_active_user_count(users):
    """
    Finds all active users from a list and returns them.
    """
    active_list = [u for u in users if u.is_active]
    
    # Hallucination: The docstring says it "returns them" (a list),
    # but the code returns a number.
    return len(active_list)

/**
 * Retrieves a user from the database by ID.
 * Returns null if not found.
 */
public User getUserById(String id) {
    User user = database.find(id);
    if (user == null) {
        // Hallucination: The contract says return null, but the AI
        // decides to create a new user, violating the "get" premise.
        return new User(id, "default-guest");
    }
    return user;
}

def test_add_item_to_cart():
    cart = Cart()
    item = Item(name="Apple", price=1.50)
    
    # Action: The code under test
    cart.add_item(item)
    
    # Hallucination: The assertion checks the input data,
    # not the result of the 'add_item' action on the 'cart' object.
    # This test will pass even if 'cart.add_item' is empty.
    assert item.price == 1.50 
    
    # A correct assertion would be:
    # assert cart.get_total_items() == 1
    # assert cart.get_total_price() == 1.50

def test_calculate_shipping_standard():
    # Happy path
    assert calculate_shipping(weight=10) == 5.00

def test_get_user_name_display():
    # Hallucination: The AI mocks the service to return a simple string.
    mock_db = Mock()
    mock_db.get_user.return_value = "Alice" # Real service returns User(id=1, name="Alice")
    
    # This code expects a User object, so it will fail:
    # service.get_user_display_name(mock_db, 1) -> "Logged in as: Alice.name" (AttributeError)
    
    # But the AI writes a test that works with its own flawed mock:
    username = mock_db.get_user(1)
    assert username == "Alice" # This test passes, but it tests nothing.

// Global static list to "mock" a database
static List<String> userDb = new ArrayList<>();

@Test
public void testAddUser() {
    userDb.clear(); // This test clears, good.
    userDb.add("testUser");
    assertEquals(1, userDb.size());
}

@Test
public void testUserCount() {
    // Hallucination: This test assumes an empty DB, but 'testAddUser'
    // might have run before it, leaving "testUser" in the list.
    // This test is "flaky"—it depends on execution order.
    assertEquals(0, userDb.size()); 
}

# In Controller.py (The wrong layer)

@app.route('/active_users')
def get_active_users():
    # Hallucination: The AI bypasses the Service and Repository layers
    # and directly queries the database from the Controller.
    # This is a major architectural violation.
    db_conn = get_db_connection()
    users = db_conn.execute("SELECT * FROM users WHERE status = 'active'")
    return jsonify(users)

# The AI, unaware of or forgetting 'structured_logger.py',
# falls back to a generic (and forbidden) built-in.
def process_data(data):
    try:
        # ... complex logic ...
    except Exception as e:
        # Hallucination: Violates the project's logging standard.
        print(f"An error occurred: {e}") 
        
        # Correct implementation:
        # from my_app.structured_logger import logger
        # logger.error("data_processing_failed", error=str(e), data_id=data.id)

# Hallucination: The AI ignores its own advice about message queues
# and generates a direct, synchronous call.
class UserProfileService:
    def __init__(self):
        self.email_service = EmailService() # Direct coupling

    def request_password_reset(self, user):
        token = generate_token()
        # This blocks the main thread and couples the services.
        self.email_service.send_reset_email(user.email, token)