if

test_if.zig

  1. // If expressions have three uses, corresponding to the three types:
  2. // * bool
  3. // * ?T
  4. // * anyerror!T
  6. const expect = @import("std").testing.expect;
  8. test "if expression" {
  9.     // If expressions are used instead of a ternary expression.
  10.     const a: u32 = 5;
  11.     const b: u32 = 4;
  12.     const result = if (a != b) 47 else 3089;
  13.     try expect(result == 47);
  14. }
  16. test "if boolean" {
  17.     // If expressions test boolean conditions.
  18.     const a: u32 = 5;
  19.     const b: u32 = 4;
  20.     if (a != b) {
  21.         try expect(true);
  22.     } else if (a == 9) {
  23.         unreachable;
  24.     } else {
  25.         unreachable;
  26.     }
  27. }
  29. test "if error union" {
  30.     // If expressions test for errors.
  31.     // Note the |err| capture on the else.
  33.     const a: anyerror!u32 = 0;
  34.     if (a) |value| {
  35.         try expect(value == 0);
  36.     } else |err| {
  37.         _ = err;
  38.         unreachable;
  39.     }
  41.     const b: anyerror!u32 = error.BadValue;
  42.     if (b) |value| {
  43.         _ = value;
  44.         unreachable;
  45.     } else |err| {
  46.         try expect(err == error.BadValue);
  47.     }
  49.     // The else and |err| capture is strictly required.
  50.     if (a) |value| {
  51.         try expect(value == 0);
  52.     } else |_| {}
  54.     // To check only the error value, use an empty block expression.
  55.     if (b) |_| {} else |err| {
  56.         try expect(err == error.BadValue);
  57.     }
  59.     // Access the value by reference using a pointer capture.
  60.     var c: anyerror!u32 = 3;
  61.     if (c) |*value| {
  62.         value.* = 9;
  63.     } else |_| {
  64.         unreachable;
  65.     }
  67.     if (c) |value| {
  68.         try expect(value == 9);
  69.     } else |_| {
  70.         unreachable;
  71.     }
  72. }

Shell

  1. $ zig test test_if.zig
  2. 1/3 test_if.test.if expression... OK
  3. 2/3 test_if.test.if boolean... OK
  4. 3/3 test_if.test.if error union... OK
  5. All 3 tests passed.

if with Optionals

test_if_optionals.zig

  1. const expect = @import("std").testing.expect;
  3. test "if optional" {
  4.     // If expressions test for null.
  6.     const a: ?u32 = 0;
  7.     if (a) |value| {
  8.         try expect(value == 0);
  9.     } else {
  10.         unreachable;
  11.     }
  13.     const b: ?u32 = null;
  14.     if (b) |_| {
  15.         unreachable;
  16.     } else {
  17.         try expect(true);
  18.     }
  20.     // The else is not required.
  21.     if (a) |value| {
  22.         try expect(value == 0);
  23.     }
  25.     // To test against null only, use the binary equality operator.
  26.     if (b == null) {
  27.         try expect(true);
  28.     }
  30.     // Access the value by reference using a pointer capture.
  31.     var c: ?u32 = 3;
  32.     if (c) |*value| {
  33.         value.* = 2;
  34.     }
  36.     if (c) |value| {
  37.         try expect(value == 2);
  38.     } else {
  39.         unreachable;
  40.     }
  41. }
  43. test "if error union with optional" {
  44.     // If expressions test for errors before unwrapping optionals.
  45.     // The |optional_value| capture's type is ?u32.
  47.     const a: anyerror!?u32 = 0;
  48.     if (a) |optional_value| {
  49.         try expect(optional_value.? == 0);
  50.     } else |err| {
  51.         _ = err;
  52.         unreachable;
  53.     }
  55.     const b: anyerror!?u32 = null;
  56.     if (b) |optional_value| {
  57.         try expect(optional_value == null);
  58.     } else |_| {
  59.         unreachable;
  60.     }
  62.     const c: anyerror!?u32 = error.BadValue;
  63.     if (c) |optional_value| {
  64.         _ = optional_value;
  65.         unreachable;
  66.     } else |err| {
  67.         try expect(err == error.BadValue);
  68.     }
  70.     // Access the value by reference by using a pointer capture each time.
  71.     var d: anyerror!?u32 = 3;
  72.     if (d) |*optional_value| {
  73.         if (optional_value.*) |*value| {
  74.             value.* = 9;
  75.         }
  76.     } else |_| {
  77.         unreachable;
  78.     }
  80.     if (d) |optional_value| {
  81.         try expect(optional_value.? == 9);
  82.     } else |_| {
  83.         unreachable;
  84.     }
  85. }

Shell

  1. $ zig test test_if_optionals.zig
  2. 1/2 test_if_optionals.test.if optional... OK
  3. 2/2 test_if_optionals.test.if error union with optional... OK
  4. All 2 tests passed.

See also: