CS 312 - Week 3.2 Class
CS 312 Audio Programming Winter 2020

cd $HOME312
git clone https://github.com/google/googletest
cd googletest
mkdir build
cd build
cmake .. && make

cd $HOME312/common
mkdir googletest
cd googletest
mkdir lib
mkdir include
cd $HOME312/googletest
cp build/lib/libgtest_main.a $HOME312/common/googletest/lib
cp build/lib/libgtest.a $HOME312/common/googletest/lib
cd googletest/include  # yes there is a googletest/googletest/include
cp -R gtest $HOME312/common/googletest/include

$HOME312/common/googletest/
├── include
│   └── gtest
│       ├── gtest-death-test.h
│       ├── gtest-matchers.h
│       ├── gtest-message.h
│       ├── gtest-param-test.h
│       ├── gtest-printers.h
│       ├── gtest-spi.h
│       ├── gtest-test-part.h
│       ├── gtest-typed-test.h
│       ├── gtest.h
│       ├── gtest_pred_impl.h
│       ├── gtest_prod.h
│       └── internal
│           ├── custom
│           │   ├── README.md
│           │   ├── gtest-port.h
│           │   ├── gtest-printers.h
│           │   └── gtest.h
│           ├── gtest-death-test-internal.h
│           ├── gtest-filepath.h
│           ├── gtest-internal.h
│           ├── gtest-param-util.h
│           ├── gtest-port-arch.h
│           ├── gtest-port.h
│           ├── gtest-string.h
│           └── gtest-type-util.h
└── lib
    ├── libgtest.a
    └── libgtest_main.a

${workspaceFolder}/**
$HOME312/common/googletest/**

// JE functions for CMidiPacket
void CMP_EQUALS(const CMidiPacket &mp, uint32_t ts, uint8_t st, uint8_t d1);
void CMP_EQUALS(const CMidiPacket &mp, uint32_t ts, uint8_t st, uint8_t d1, uint8_t d2);
bool CMP_EQUALS(const CMidiPacket &mp1, const CMidiPacket &mp2);
// END JE functions for CMidiPacket

// the first parameter is the test group name
// the second parameter is the test name
// you can have multiple tests in a group as long as their names are unique
// it will be reported as overload.constructor_two_data_bytes
TEST(overload, constructor_two_data_bytes)
{
    CMidiPacket mp{1001, 0x91, 61, 101};
    CMP_EQUALS(mp, 1001, 0x91, 61, 101);
}

TEST(overload, constructor_string1)
{
    std::string s{"100\tc0\t11"};
    CMidiPacket mp(s);
    // compares c style strings (char *str)
    EXPECT_STREQ(mp.to_string().c_str(), s.c_str());
}

TEST(io_input, operator_input2)
{
    std::string s = "1000\t90\t60\t100";
    std::istringstream iss(s);
    CMidiPacket A;
    iss >> A;
    EXPECT_EQ(A.to_string(), s);
}

TEST(is_status, is_note_off2)
{
    CMidiPacket mp2(1001, 0x91, 61, 0);
    EXPECT_TRUE(mp2.is_note_off());
}

TEST(big6, copy_constructor2)
{
    CMidiPacket C{5678, 0x98, 99, 100};
    CMidiPacket D(C);
    EXPECT_TRUE(CMP_EQUALS(C, D));
}

TEST(big6, move_assignment_operator2)
{
    CMidiPacket A{1001, 0x91, 61, 101};
    CMidiPacket B;
    B = std::move(A);
    EXPECT_TRUE(CMP_EQUALS(A, B));
}

TEST(less, lessthan4a)
{
    CMidiPacket A = {1000, 0x91, 61, 101};
    CMidiPacket B = {1000, 0x91, 60, 0};
    EXPECT_FALSE(A < B);
}

# cd build
emptybuildfolder.sh
cmake .. && make
./gtestCMP32

[==========] Running 75 tests from 12 test suites.
[----------] Global test environment set-up.
[----------] 1 test from dc
[----------] 6 tests from big6
[----------] 5 tests from overload
[----------] 3 tests from to_string
[----------] 7 tests from get
[----------] 5 tests from set
[----------] 18 tests from is_status
[----------] 2 tests from io_out
[----------] 4 tests from io_in
[----------] 6 tests from eq
[----------] 5 tests from less_helper
[----------] 13 tests from less

[----------] Global test environment tear-down
[==========] 75 tests from 12 test suites ran. (6 ms total)
[  PASSED  ] 59 tests.
[  FAILED  ] 16 tests, listed below:
[  FAILED  ] io_out.operator_output1
[  FAILED  ] io_out.operator_output2
[  FAILED  ] io_in.operator_input1
[  FAILED  ] io_in.operator_input1a
[  FAILED  ] io_in.operator_input2
[  FAILED  ] io_in.operator_input3
[  FAILED  ] eq.operator_equals1
[  FAILED  ] eq.operator_equals2
[  FAILED  ] less.lessthan2
[  FAILED  ] less.lessthan3
[  FAILED  ] less.lessthan5
[  FAILED  ] less.lessthan8
[  FAILED  ] less.lessthan9
[  FAILED  ] less.lessthan11
[  FAILED  ] less.lessthan12
[  FAILED  ] less.lessthan13

bool CMP32::operator<(const CMidiPacket &a, const CMidiPacket &b)

// the most complicated overload in CMidiPacket
// This function will be called repeatedly by sort() until the vector is sorted
// if variable is_a_first = true it means CMidiPacket a will come before CMidiPacket #+BEGIN_EXAMPLE
// Remember if a == b then a is not less than b
bool CMP32::operator<(const CMidiPacket &a, const CMidiPacket &b)
{
  bool is_a_first = false;

  // Sorting rules when timestamps are equal
  // std::cout << "# A " << a << "# B " << b;
  if (a.timestamp_ < b.timestamp_)
  {
    // lowest timestamp_ always comes first.
    is_a_first = true;
  }
  else if (a.timestamp_ == b.timestamp_)
  {
    // std::cout << "# (a.timestamp_ == b.timestamp_)\n";
    // NOF comes before anything
    if (a.is_note_off())
    {
      switch (b.status_ & 0xF0)
      {
      case 0x90:
      case 0xA0:
      case 0xB0:
      case 0xD0:
      case 0xE0:
        is_a_first = true; // means NOF comes before the five above
        break;
      case 0x80: // if a==b, a not < b
      case 0xC0:
        is_a_first = false; // means NOF comes after the two above
        break;
      default:
        break;
      }
    }

    else if (a.is_note_on())
    {
      switch (b.status_ & 0xF0)
      {
        // use all cases 0x80-0xE0
        // decide when a comes before
        // decide when a comes after
      }
    }

    if (a.is_status_An())
    {
      switch (b.status_ & 0xF0)
      {
        // use all cases 0x80-0xE0
        // decide when a comes before
        // decide when a comes after
      }
    }

    if (a.is_status_Bn())
    {
      switch (b.status_ & 0xF0)
      {
        // use all cases 0x80-0xE0
        // decide when a comes before
        // decide when a comes after
      }
    }

    if (a.is_status_Cn())
    {
      switch (b.status_ & 0xF0)
      {
        // use all cases 0x80-0xE0
        // decide when a comes before
        // decide when a comes after
      }
    }

    if (a.is_status_Dn())
    {
      switch (b.status_ & 0xF0)
      {
        // use all cases 0x80-0xE0
        // decide when a comes before
        // decide when a comes after
      }
    }

    if (a.is_status_En())
    {
      switch (b.status_ & 0xF0)
      {
        // use all cases 0x80-0xE0
        // decide when a comes before
        // decide when a comes after
      }
    }
  }
  return is_a_first;
}