Can you write a test driver for this code and tell me if it compiles?

USLList.h file

#pragma once

#include "Node.h"

#include "ItemType.h"

class USLList {

public:

USLList();

~USLList();

bool isEmpty() const;

int getLength() const;

void insertItem(ItemType &item);

void deleteItem(ItemType &item);

bool searchItem(ItemType &item) const;

void printList() const;

void reverseList();

private:

Node *head;

int length;

};

USLList.cpp file

#include "USLList.h"

#include

USLList::USLList() {

head = nullptr;

length = 0;

}

USLList::~USLList() {

Node *curr = head;

while (curr != nullptr) {

Node *temp = curr;

curr = curr->getNext();

delete temp;

}

}

bool USLList::isEmpty() const {

return head == nullptr;

}

int USLList::getLength() const {

return length;

}

void USLList::insertItem(ItemType &item) {

Node *newNode = new Node();

newNode->setItem(item);

newNode->setNext(head);

head = newNode;

length++;

}

void USLList::deleteItem(ItemType &item) {

Node *curr = head;

Node *prev = nullptr;

while (curr != nullptr && !(curr->getItem().compareTo(item))) {

prev = curr;

curr = curr->getNext();

}

if (curr == nullptr) {

std::cout << "Item not found in the list." << std::endl;

return;

}

if (prev == nullptr) {

head = curr->getNext();

} else {

prev->setNext(curr->getNext());

}

delete curr;

length--;

}

bool USLList::searchItem(ItemType &item) const {

Node *curr = head;

while (curr != nullptr && !(curr->getItem().compareTo(item))) {

curr = curr->getNext();

}

return curr != nullptr;

}

void USLList::printList() const {

Node *curr = head;

while (curr != nullptr) {

std::cout << curr->getItem().getData() << " ";

curr = curr->getNext();

}

std::cout << std::endl;

}

void USLList::reverseList() {

Node *prev = nullptr;

Node *curr = head;

Node *next = nullptr;

while (curr != nullptr) {

next = curr->getNext();

curr->setNext(prev);

prev = curr;

curr = next;

}

head = prev;

};

Node.h file

#pragma once

#include "ItemType.h"

class Node {

public:

Node();

~Node();

void setItem(ItemType &item);

ItemType getItem() const;

void setNext(Node *node);

Node* getNext() const;

private:

ItemType item;

Node *next;

};

Node.cpp file

#include "Node.h"

Node::Node() {

next = nullptr;

}

Node::~Node() {

}

void Node::setItem(ItemType &item) {

this->item = item;

}

ItemType Node::getItem() const {

return item;

}

void Node::setNext(Node *node) {

next = node;

}

Node* Node::getNext() const {

return next;

};

ItemType.h file

#pragma once

class ItemType {

public:

ItemType();

ItemType(int data);

~ItemType();

void setData(int data);

};

ItemType.cpp file

#include "ItemType.h"

ItemType::ItemType() {

value = 0;

}

ItemType::ItemType(int value) {

this->value = value;

}

int ItemType::getValue() const {

return value;

}

void ItemType::setValue(int value) {

this->value = value;

}

bool ItemType::operator==(const ItemType& other) const {

return value == other.value;

};