// -------------
// Operators.c++
// -------------

#include <cassert>  // assert
#include <iostream> // cout, endl

int main () {
    using namespace std;
    cout << "Operators.c++" << endl;

    {
    const int i = 2;
    const int j = -i;
    assert(i ==  2);
    assert(j == -2);
//  ++-i;                            // error: lvalue required as increment operand
    }

    {
    int i = 2;
    int j = ++i;
    assert(i == 3);
    assert(j == 3);
    ++++i;
    assert(i == 5);
    (++i)++;
    assert(i == 7);
    }

    {
    int i = 2;
    int j = i++;
    assert(i == 3);
    assert(j == 2);
//  i++++;                           // error: lvalue required as increment operand
//  ++(i++);                         // error: lvalue required as increment operand
    }

    {
          int i = 2;
    const int j = 3;
    const int k = (i = j);
    assert(i == 3);
    assert(j == 3);
    assert(k == 3);
    ++(i = j);
    assert(i == 4);
    }

    {
    const int i = 2;
    const int j = 3;
    const int k = i + j;
    assert(i == 2);
    assert(j == 3);
    assert(k == 5);
//  ++(i + j);                       // error: lvalue required as increment operand
    }

    {
          int i = 2;
    const int j = 3;
    int k = (i += j);
    assert(i == 5);
    assert(j == 3);
    assert(k == 5);
    ++(i += j);
    assert(i == 9);
    }

    {
    const int i = 12;
    const int j = 10;
    const int k = i / j;             // integer division
    assert(i == 12);
    assert(j == 10);
    assert(k ==  1);
//  ++(i / j);                       // error: lvalue required as increment operand
    }

    {
          int i = 12;
    const int j = 10;
    const int k = (i /= j);
    assert(i ==  1);
    assert(j == 10);
    assert(k ==  1);
    ++(i /= j);
    assert(i ==  1);
    }

    {
    const int i = 12;
    const int j = 10;
    const int k = i % j;
    assert(i == 12);
    assert(j == 10);
    assert(k ==  2);
//  ++(i % j);                       // error: lvalue required as increment operand
    }

    {
          int i = 12;
    const int j = 10;
    const int k = (i %= j);
    assert(i ==  2);
    assert(j == 10);
    assert(k ==  2);
    ++(i %= j);
    assert(i ==  3);
    }

    {
    const int i = 2;
    const int j = 3;
    const int k = i << j;
    assert(i == 2);
    assert(j == 3);
    assert(k == 16);
//  ++(i << j);                      // error: lvalue required as increment operand
    }

    {
          int i = 2;
    const int j = 3;
    const int k = (i <<= j);
    assert(i ==  16);
    assert(j ==   3);
    assert(k ==  16);
    ++(i <<= j);
    assert(i == 129);
    }

    {
    const int i = 10;                // 0000 0000 0000 1010
    const int j = ~i;                // 1111 1111 1111 0101
    const int k = ~i + 1;            // 1111 1111 1111 0110
    assert(i ==  10);
    assert(j == -11);
    assert(k == -10);
//  ++~i;                            // error: lvalue required as increment operand
    }

    {
    const int i = 10;                // 1010
    const int j = 12;                // 1100
    const int k = i & j;             // 1000
    assert(i == 10);
    assert(j == 12);
    assert(k ==  8);
//  ++(i & j);                       // error: lvalue required as increment operand
    }

    {
          int i = 10;                // 1010
    const int j = 12;                // 1100
    const int k = (i &= j);          // 1000
    assert(i ==  8);
    assert(j == 12);
    assert(k ==  8);
    ++(i &= j);                      // 1001
    assert(i ==  9);
    }

    {
    const int i = 10;                // 1010
    const int j = 12;                // 1100
    const int k = i | j;             // 1110
    assert(i == 10);
    assert(j == 12);
    assert(k == 14);
//  ++(i | j);                       // error: lvalue required as increment operand
    }

    {
          int i = 10;                // 1010
    const int j = 12;                // 1100
    const int k = (i |= j);          // 1110
    assert(i == 14);
    assert(j == 12);
    assert(k == 14);
    ++(i |= j);                      // 1111
    assert(i == 15);
    }

    {
    const int i = 10;                // 1010
    const int j = 12;                // 1100
    const int k = i ^ j;             // 0110
    assert(i == 10);
    assert(j == 12);
    assert(k ==  6);
//  ++(i ^ j);                       // error: lvalue required as increment operand
    }

    {
          int i = 10;                // 1010
    const int j = 12;                // 1100
    const int k = (i ^= j);          // 0110
    assert(i ==  6);
    assert(j == 12);
    assert(k ==  6);
    ++(i ^= j);                      // 1011
    assert(i == 11);
    }

    {
    int i = 10;                      // 1010
    int j = 12;                      // 1100
    i ^= j;
    assert(i ==  6);                 // 0110
    assert(j == 12);                 // 1100
    j ^= i;
    assert(i ==  6);                 // 0110
    assert(j == 10);                 // 1010
    i ^= j;
    assert(i == 12);                 // 1100
    assert(j == 10);                 // 1010
    }

    {
    int i = 10;
    int j = 12;
    i += j;
    assert(i == 22);
    assert(j == 12);
    j = i - j;
    assert(i == 22);
    assert(j == 10);
    i -= j;
    assert(i == 12);
    assert(j == 10);
    }

    {
    const bool a = true;
    const bool b = true;
    const bool c = false;
    assert(a && b);
    assert(!(a && c));
    assert(a || b);
    assert(a || c);
    assert((a && b) == !(!a || !b));
    assert((a && c) == !(!a || !c));
    }

    {
    int a[] = {2, 3, 4};
    assert(a[1] == 3);
    ++a[1];
    assert(a[1] == 4);
    }

    cout << "Done." << endl;
    return 0;}