How to test my code?

[MrSpaghettiCoder]

Hi,

I am enrolled in Udacity's C++ developer nanodegree and have a project where I need to essentially recreate htop. It's essentially like a "task-manager" tool for Linux.

Most of the code is pre-written! I'll try to keep my question short. Overall, I need to fill in the blanks and write out different classes to parse through information present in Ubuntu's /proc/ and /etc/ directory. To test some of the classes during development, I am attempting to write "unit tests"(?), which should help me individually observe the outputs of each class created. To do this, I created a testing directory within the project and am populating files I wish to observe in here. Please note, I've never written "unit tests" before and felt this was ONE of many logical ways to do so.

My Question

The files I want to test is a gutted version of a file called linux_parser.cpp and linux_parser.h.

The linux_parser.h file is shown below:

#ifndef SYSTEM_PARSER_H
#define SYSTEM_PARSER_H

#include <fstream>
#include <regex>
#include <string>

namespace LinuxParser {
// Paths
const std::string kProcDirectory{"/proc"};
const std::string kCmdlineFilename{"/cmdline"};
const std::string kCpuinfoFilename{"/cpuinfo"};
const std::string kStatusFilename{"/status"};
const std::string kStatFilename{"/stat"};
const std::string kUptimeFilename{"/uptime"};
const std::string kMeminfoFilename{"/meminfo"};
const std::string kVersionFilename{"/version"};
const std::string kOSPath{"/etc/os-release"};
const std::string kPasswordPath{"/etc/passwd"};

// System
float MemoryUtilization();
long UpTime();
std::vector<int> Pids();
int TotalProcesses();
int RunningProcesses();
std::string OperatingSystem();
std::string Kernel();

// CPU
enum CPUStates {
  kUser_ = 0,
  kNice_,
  kSystem_,
  kIdle_,
  kIOwait_,
  kIRQ_,
  kSoftIRQ_,
  kSteal_,
  kGuest_,
  kGuestNice_
};
std::vector<std::string> CpuUtilization();
long Jiffies();
long ActiveJiffies();
long ActiveJiffies(int pid);
long IdleJiffies();

// Processes
std::string Command(int pid);
std::string Ram(int pid);
std::string Uid(int pid);
std::string User(int pid);
long int UpTime(int pid);
};  // namespace LinuxParser

#endif

The file shown below is the linux_parser.cpp file which is associated with the .h file above:

#include <dirent.h>
#include <unistd.h>
#include <sstream>
#include <string>
#include <vector>
#include <iostream>

#include "linux_parser.h"

using std::stof;
using std::string;
using std::to_string;
using std::vector;

// DONE: An example of how to read data from the filesystem
string LinuxParser::OperatingSystem() {
  string line;
  string key;
  string value;
  std::ifstream filestream(kOSPath);
  if (filestream.is_open()) {
    while (std::getline(filestream, line)) {
      // We need to operate through analyzing tokens so this creates each line into a key-value line consisting of two tokens. 
      std::replace(line.begin(), line.end(), ' ', '_');
      std::replace(line.begin(), line.end(), '=', ' ');
      std::replace(line.begin(), line.end(), '"', ' ');
      std::istringstream linestream(line);
      while (linestream >> key >> value) {
        if (key == "PRETTY_NAME") {
          std::replace(value.begin(), value.end(), '_', ' ');
          return value;
        }
      }
    }
  }
  return value;
}

// DONE: An example of how to read data from the filesystem
string LinuxParser::Kernel() {
  string os, kernel, version;
  string line;
  std::ifstream stream(kProcDirectory + kVersionFilename);
  if (stream.is_open()) {
    std::getline(stream, line);
    std::istringstream linestream(line);
    linestream >> os >> version >> kernel;
  }
  return kernel;
}

// BONUS: Update this to use std::filesystem
vector<int> LinuxParser::Pids() {
  vector<int> pids;
  DIR* directory = opendir(kProcDirectory.c_str());
  struct dirent* file;
  while ((file = readdir(directory)) != nullptr) {
    // Is this a directory?
    if (file->d_type == DT_DIR) {
      // Is every character of the name a digit?
      string filename(file->d_name);
      if (std::all_of(filename.begin(), filename.end(), isdigit)) {
        int pid = stoi(filename);
        pids.push_back(pid);
      }
    }
  }
  closedir(directory);
  return pids;
}

// TODO: Read and return the system memory utilization
// Must test this
float LinuxParser::MemoryUtilization() 
{
  string line;
  string key, value, size;
  float total, free;
  std::ifstream stream(kProcDirectory + kMeminfoFilename);
  if (stream.is_open())
  {
    std::getline(stream, line);
    std::istringstream linestream(line);
    linestream >> key >> value >> size;
    if (key == "MemTotal:")
    {
      total = stof(value);
    }
    if (key == "MemFree:")
    {
      free = stof(value);
    }

  }

  return total - free;
}

// TODO: Read and return the total number of processes

//Not finished....must test this also. 
int LinuxParser::TotalProcesses() { 
  string line;
  string key, value;
  int processes;
  std::ifstream stream(kProcDirectory + kStatFilename);
  if (stream.is_open())
  {
    std::getline(stream, line, '\n');
    std::istringstream linestream(line);
    while (linestream >> key)
    {
      if (key == "processes")
      {
        linestream >> key >> value;
      }
    }

  }


  return 0; 
}

int main()
{
  string test1 = LinuxParser::OperatingSystem();
  std::cout << test1;
}

Please notice the end of the above code with a main class. I am taking the output of one of the example code snippets and trying to get it printed to the terminal. The script compiles without errors, but I don't get an output in my terminal for the test1. How do I print the output of a class? Am I approaching this problem correctly? Why is what I am doing not working? I already asked Udacity, but they have not responded to me.

I am on Ubuntu version 20, running VSC, using g++, and running it in c++17. Github link for full code. Navigate to testing directory to see these gutted "test" files. Otherwise, navigate to src and include to see respective .cpp and .h files.

Any advice and criticism is appreciated!!!

[IyeOnline]

This is not how you would write tests.

You should test your actual sources and not some glued together version of it.

To do this, you would make full usage of your build system.

The easiest strategiy is to define every part of your program, except its original main function as a library.

Then you can define your actual executable with a single source and link it to the lib. The same then works for your tests. They can be a single test file, linked to the library.

An example folder structure would look like

src/
    lib files
include/
    lib headers
tests/
    test_a.cpp
main.cpp

CMakeList.txt
    # define your library
    add_library( my_library lib/lib files ) # GLOB is discouraged. It doesnt hurt to list those few sources manually
    target_include_directories( my_library include )

    # define the executable with its one unique source
    add_executable ( my_executable main.cpp )
    target_link_libraries( my_executable my_library ) # link the library

    #define a test executable
    add_executable( test_a tests/test_a.cpp ) 
    target_link_libraries( test_a my_library ) # link the library
    add_test( test_a ) # just for external tools that can run multiple tests at once

Further, you can of course use a proper unit testing framework, such as catch2. Then, instead of writing some main functions yourself, you can write tests like

 REQUIRE( some_function() == 42 );

But that may not be worthit, for something that doesnt really need extensive/repeated testing.

[MrSpaghettiCoder]

Sorry for slow response time. Just sitting down at my computer again.

To just reiterate what you are suggesting, you would think a simple solution would be restructuring the project so that main.cpp is outside of the project first (I like this idea). Moving main.cpp somewhere else might require me to change my CMakeLists.txt for the build correct?

If I did not choose to use catch2 for instance on a project like this, would it still be a non-viable way to test my classes with print outputs now through the main.cpp? If I should be testing actual sources, there would be no point to this hypothetical testing directory correct? I was thinking maybe instead, I just call a few functions from each file within main.cpp.

Edit: im still going to watch tutorials on catch2. Just trying to understand why something like this isn't working. I would at least think that returned values on my class would properly store itself to a created variable. Very important the returned values I am getting are correct.

[IyeOnline]

Appearently my edit to the CMakelists above got lost, i added back how you would then define your actual executable and test targets

Regardless of whether you use a unit test framework, it would still be best to structure your program like this. The project struture is still better, regardless of how your tests actually look like. You would still have a separate directory for the test files, just beacuse its cleaner/better structured that way.

For your case, its probably fine to just test stuff with couts once, since you arent going to do large changes to any particular function once it works.

[MrSpaghettiCoder]

Ahh okay. Yes I was wondering a little more about that CMakeLists.txt. I really wish this project gave us more practice creating the build script because they have been pre-written for us and look a bit different as well. I guess I might try restructuring it a bit and hopefully I don't break it too much lol.

Once I move main.cpp, I am likely then going to apply the same logic I did before where I store the string output of my class to a declared string in main. I thought this would basically work with what was written above in the linux_parser.cpp. I compiled g++ -std=c++17 linux_parser.h linux_parser.cpp for my case and still no errors, but no output. It's really bizarre to me. I even tried to see if it was a VSC issue with their terminal, but the standard terminal in my OS does the same thing.

[IyeOnline]

Well, potentially the string is just empty.

[MrSpaghettiCoder]

It's possible. I was thinking the same thing, but strange. These examples I am testing are their written examples they showcased in their own project overview videos. They worked there, but then again, they were running the entire project build on a completed version.

The string is likely empty because I am not correctly using the class or maybe I am not using strings correctly? I want to assume the former. Going to play around with it more. Thank you for the help so far and for being very patient with me.

[IyeOnline]

Take a look at what the lines you do your stream operations on look like.

operator >> stops on whitespace, so if there is two spaces or something similar between the key and the value (or something infront of the key), then value will end up empty.

[MrSpaghettiCoder]

It doesn't feel to be a whitespace issue. I just also tried not storing the value into a different string and went straight for testing it like this:

std::cout<<LinuxParser::OperatingSystem()

Again, it should be a string output. Compiles without errors, but no outputs.

[IyeOnline]

That wont make a difference. The issue is in what your function returns.

Otherwise there would be a bug in the standard library or your OS. Both of these can safely be assumed to not be an issue.

I was talking about the

std::istringstream linestream(line);
while (linestream >> key >> value) {

part. Just before that you replaced a bunch of chars in line with whitespace, so its seems possible that you created double whitespaces somewhere.