diff --git a/Makefile.am b/Makefile.am
index 5a26916..cf1f987 100644
--- a/Makefile.am
+++ b/Makefile.am
@@ -1,10 +1,23 @@
 ACLOCAL_AMFLAGS = -I m4
 sbin_PROGRAMS = mboxd mboxctl
 
-mboxd_SOURCES = mboxd.c common.c mboxd_dbus.c mboxd_flash.c mboxd_lpc.c mboxd_msg.c mboxd_windows.c mtd.c
+mboxd_SOURCES = \
+	mboxd.c \
+	common.c \
+	mboxd_dbus.c \
+	mboxd_flash.c \
+	mboxd_lpc.c \
+	mboxd_msg.c \
+	mboxd_windows.c \
+	mtd.c
 mboxd_LDFLAGS = $(LIBSYSTEMD_LIBS)
 mboxd_CFLAGS = $(LIBSYSTEMD_CFLAGS)
 
+if VIRTUAL_PNOR_ENABLED
+mboxd_SOURCES += pnor_partition_table.cpp
+mboxd_LDFLAGS += -lstdc++fs
+endif
+
 mboxctl_SOURCES = mboxctl.c
 mboxctl_LDFLAGS = $(LIBSYSTEMD_LIBS)
 mboxctl_CFLAGS = $(LIBSYSTEMD_CFLAGS)
@@ -14,6 +27,7 @@
 AM_LIBS = $(CODE_COVERAGE_LIBS)
 AM_CPPFLAGS = $(CODE_COVERAGE_CPPFLAGS)
 AM_CFLAGS = $(CODE_COVERAGE_CFLAGS)
+AM_CXXFLAGS = $(CODE_COVERAGE_CXXFLAGS)
 
 test_sanity_SOURCES = test/sanity.c
 
@@ -95,6 +109,12 @@
 test_get_mbox_info_v2_timeout_SOURCES = test/get_mbox_info_v2_timeout.c \
 					$(TEST_MBOX_SRCS) $(TEST_MOCK_SRCS)
 
+test_create_pnor_partition_table_SOURCES = \
+	test/create_pnor_partition_table.cpp \
+	common.c \
+	pnor_partition_table.cpp
+test_create_pnor_partition_table_LDFLAGS = -lstdc++fs
+
 check_PROGRAMS = test/sanity \
 		 test/copy_flash \
 		 test/erase_flash \
@@ -123,4 +143,8 @@
 		 test/sequence_numbers \
 		 test/get_mbox_info_v2_timeout
 
+if VIRTUAL_PNOR_ENABLED
+check_PROGRAMS += test/create_pnor_partition_table
+endif
+
 TESTS = $(check_PROGRAMS)
diff --git a/common.h b/common.h
index 83ead0c..90a0fc9 100644
--- a/common.h
+++ b/common.h
@@ -46,6 +46,10 @@
 
 extern void (*mbox_vlog)(int p, const char *fmt, va_list args);
 
+#ifdef __cplusplus
+extern "C" {
+#endif
+
 void mbox_log_console(int p, const char *fmt, va_list args);
 
 __attribute__((format(printf, 2, 3)))
@@ -100,4 +104,8 @@
 
 char *get_dev_mtd(void);
 
+#ifdef __cplusplus
+}
+#endif
+
 #endif /* COMMON_H */
diff --git a/configure.ac b/configure.ac
index c5ef78a..a523948 100644
--- a/configure.ac
+++ b/configure.ac
@@ -66,6 +66,9 @@
 AC_SUBST([LIBSYSTEMD_CFLAGS])
 AC_SUBST([LIBSYSTEMD_LIBS])
 
+AC_DEFINE(PARTITION_TOC_FILE, "pnor.toc", [The basename of the PNOR Table of contents file.])
+AC_DEFINE(PARTITION_FILES_LOC, "/var/lib/phosphor-software-manager/pnor/ro", [The path to the directory containing PNOR partition files.])
+
 # Create configured output
 AC_CONFIG_FILES([Makefile])
 AC_OUTPUT
diff --git a/pnor_partition_defs.h b/pnor_partition_defs.h
new file mode 100644
index 0000000..836dac5
--- /dev/null
+++ b/pnor_partition_defs.h
@@ -0,0 +1,121 @@
+#pragma once
+
+#include <stdint.h>
+#include <sys/types.h>
+
+/* There are two structures outlined here - one that represents the PNOR
+ * partition table (or header) - this appears first in the PNOR image.
+ * The last field of the PNOR partition table structure is an array
+ * of another structure - which represents the partition.
+ *
+ * The flash structures used here have been borrowed from
+ * https://github.com/open-power/hostboot/blob/master/src/usr/pnor/ffs.h */
+
+
+/* The maximum length of a partition's name */
+#define PARTITION_NAME_MAX 15
+
+/* The version of this partition implementation. This is an
+ * incrementing value */
+#define PARTITION_VERSION_1 1
+
+/* Magic number for the partition partition_table (ASCII 'PART') */
+#define PARTITION_HEADER_MAGIC 0x50415254
+
+/* Default parent partition id */
+#define PARENT_PATITION_ID 0xFFFFFFFF
+
+/* The partition structure has 16 'user data' words, which can be used to store
+ * miscellaneous information. This is typically used to store bits that state
+ * whether a partition is ECC protected, is read-only, is preserved across
+ * updates, etc. */
+#define PARTITION_USER_WORDS 16
+#define PARTITION_ECC_PROTECTED 0x8000
+#define PARTITION_PRESERVED 0x80000000
+#define PARTITION_READONLY 0x40000000
+
+/* Partition flags */
+enum partition_flags {
+    PARTITION_FLAGS_PROTECTED = 0x0001,
+    PARTITION_FLAGS_U_BOOT_ENV = 0x0002
+};
+
+/* Type of image contained within partition */
+enum partition_type {
+    PARTITION_TYPE_DATA = 1,
+    PARTITION_TYPE_LOGICAL = 2,
+    PARTITION_TYPE_PARTITION = 3
+};
+
+
+/**
+ * struct pnor_partition
+ *
+ * @name:       Name of the partition - a null terminated string
+ * @base:       The offset in the PNOR, in block-size (1 block = 4KB),
+ *              where this partition is placed
+ * @size:       Partition size in blocks.
+ * @pid:        Parent partition id
+ * @id:         Partition ID [1..65536]
+ * @type:       Type of partition, see the 'type' enum
+ * @flags:      Partition flags (optional), see the 'flags' enum
+ * @actual:     Actual partition size (in bytes)
+ * @resvd:      Reserved words for future use
+ * @user:       User data (optional), see user data macros above
+ * @checksum:   Partition checksum (includes all words above) - the
+ *              checksum is obtained by a XOR operation on all of the
+ *              words above. This is used for detecting a corruption
+ *              in this structure
+ */
+struct pnor_partition {
+    struct {
+        char         name[PARTITION_NAME_MAX + 1];
+        uint32_t     base;
+        uint32_t     size;
+        uint32_t     pid;
+        uint32_t     id;
+        uint32_t     type;
+        uint32_t     flags;
+        uint32_t     actual;
+        uint32_t     resvd[4];
+        struct
+        {
+            uint32_t data[PARTITION_USER_WORDS];
+        } user;
+    } __attribute__ ((packed)) data;
+    uint32_t     checksum;
+} __attribute__ ((packed));
+
+/**
+ * struct pnor_partition_table
+ *
+ * @magic:          Eye catcher/corruption detector - set to
+ *                  PARTITION_HEADER_MAGIC
+ * @version:        Version of the structure, set to
+ *                  PARTITION_VERSION_1
+ * @size:           Size of partition table (in blocks)
+ * @entry_size:     Size of struct pnor_partition element (in bytes)
+ * @entry_count:    Number of struct pnor_partition elements in partitions array
+ * @block_size:     Size of an erase-block on the PNOR (in bytes)
+ * @block_count:    Number of blocks on the PNOR
+ * @resvd:          Reserved words for future use
+ * @checksum:       Header checksum (includes all words above) - the
+ *                  checksum is obtained by a XOR operation on all of the
+ *                  words above. This is used for detecting a corruption
+ *                  in this structure
+ * @partitions:     Array of struct pnor_partition
+ */
+struct pnor_partition_table {
+    struct {
+        uint32_t         magic;
+        uint32_t         version;
+        uint32_t         size;
+        uint32_t         entry_size;
+        uint32_t         entry_count;
+        uint32_t         block_size;
+        uint32_t         block_count;
+        uint32_t         resvd[4];
+    } __attribute__ ((packed)) data;
+    uint32_t         checksum;
+    struct pnor_partition partitions[];
+} __attribute__ ((packed));
diff --git a/pnor_partition_table.cpp b/pnor_partition_table.cpp
new file mode 100644
index 0000000..17f5011
--- /dev/null
+++ b/pnor_partition_table.cpp
@@ -0,0 +1,242 @@
+#include "pnor_partition_table.hpp"
+#include "common.h"
+#include "config.h"
+#include <syslog.h>
+#include <endian.h>
+#include <regex>
+#include <fstream>
+#include <algorithm>
+
+namespace openpower
+{
+namespace virtual_pnor
+{
+
+namespace partition
+{
+namespace block
+{
+
+// The PNOR erase-block size is 4 KB
+constexpr size_t size = 4096;
+
+} // namespace block
+
+Table::Table():
+    Table(fs::path(PARTITION_FILES_LOC))
+{
+}
+
+Table::Table(fs::path&& directory):
+    szBlocks(0),
+    imgBlocks(0),
+    directory(std::move(directory)),
+    numParts(0)
+{
+    preparePartitions();
+    prepareHeader();
+    hostTbl = endianFixup(tbl);
+}
+
+void Table::prepareHeader()
+{
+    decltype(auto) table = getNativeTable();
+    table.data.magic = PARTITION_HEADER_MAGIC;
+    table.data.version = PARTITION_VERSION_1;
+    table.data.size = szBlocks;
+    table.data.entry_size = sizeof(pnor_partition);
+    table.data.entry_count = numParts;
+    table.data.block_size = block::size;
+    table.data.block_count = imgBlocks;
+    table.checksum = details::checksum(table.data);
+}
+
+inline void Table::allocateMemory(const fs::path& tocFile)
+{
+    size_t num = 0;
+    std::string line;
+    std::ifstream file(tocFile.c_str());
+
+    // Find number of lines in partition file - this will help
+    // determine the number of partitions and hence also how much
+    // memory to allocate for the partitions array.
+    // The actual number of partitions may turn out to be lesser than this,
+    // in case of errors.
+    while (std::getline(file, line))
+    {
+        // Check if line starts with "partition"
+        if (std::string::npos != line.find("partition", 0))
+        {
+            ++num;
+        }
+    }
+
+    size_t totalSizeBytes = sizeof(pnor_partition_table) +
+                            (num * sizeof(pnor_partition));
+    size_t totalSizeAligned = align_up(totalSizeBytes, block::size);
+    szBlocks = totalSizeAligned / block::size;
+    imgBlocks = szBlocks;
+    tbl.resize(totalSizeAligned);
+}
+
+inline void Table::writeSizes(pnor_partition& part, size_t start, size_t end)
+{
+    size_t size = end - start;
+    part.data.base = imgBlocks;
+    size_t sizeInBlocks = align_up(size, block::size) / block::size;
+    imgBlocks += sizeInBlocks;
+    part.data.size = sizeInBlocks;
+    part.data.actual = size;
+}
+
+inline void Table::writeUserdata(pnor_partition& part, const std::string& data)
+{
+    if (std::string::npos != data.find("ECC"))
+    {
+        part.data.user.data[0] = PARTITION_ECC_PROTECTED;
+    }
+    auto perms = 0;
+    if (std::string::npos != data.find("READONLY"))
+    {
+        perms |= PARTITION_READONLY;
+    }
+    if (std::string::npos != data.find("PRESERVED"))
+    {
+        perms |= PARTITION_PRESERVED;
+    }
+    part.data.user.data[1] = perms;
+}
+
+inline void Table::writeDefaults(pnor_partition& part)
+{
+    part.data.pid = PARENT_PATITION_ID;
+    part.data.type = PARTITION_TYPE_DATA;
+    part.data.flags = 0; // flags unused
+}
+
+inline void Table::writeNameAndId(pnor_partition& part, std::string&& name,
+                                  const std::string& id)
+{
+    name.resize(PARTITION_NAME_MAX);
+    memcpy(part.data.name,
+           name.c_str(),
+           sizeof(part.data.name));
+    part.data.id = std::stoul(id);
+}
+
+void Table::preparePartitions()
+{
+    fs::path tocFile = directory;
+    tocFile /= PARTITION_TOC_FILE;
+    allocateMemory(tocFile);
+
+    std::ifstream file(tocFile.c_str());
+    static constexpr auto ID_MATCH = 1;
+    static constexpr auto NAME_MATCH = 2;
+    static constexpr auto START_ADDR_MATCH = 3;
+    static constexpr auto END_ADDR_MATCH = 4;
+    // Parse PNOR toc (table of contents) file, which has lines like :
+    // partition01=HBB,00010000,000a0000,ECC,PRESERVED, to indicate partitions
+    std::regex regex
+    {
+        "^partition([0-9]+)=([A-Za-z0-9_]+),"
+        "([0-9a-fA-F]+),([0-9a-fA-F]+)",
+        std::regex::extended
+    };
+    std::smatch match;
+    std::string line;
+
+    decltype(auto) table = getNativeTable();
+
+    while (std::getline(file, line))
+    {
+        if (std::regex_search(line, match, regex))
+        {
+            fs::path partitionFile = directory;
+            partitionFile /= match[NAME_MATCH].str();
+            if (!fs::exists(partitionFile))
+            {
+                MSG_ERR("Partition file %s does not exist",
+                         partitionFile.c_str());
+                continue;
+            }
+
+            writeNameAndId(table.partitions[numParts],
+                           match[NAME_MATCH].str(),
+                           match[ID_MATCH].str());
+            writeDefaults(table.partitions[numParts]);
+            writeSizes(table.partitions[numParts],
+                       std::stoul(match[START_ADDR_MATCH].str(), nullptr, 16),
+                       std::stoul(match[END_ADDR_MATCH].str(), nullptr, 16));
+            writeUserdata(table.partitions[numParts], match.suffix().str());
+            table.partitions[numParts].checksum =
+                details::checksum(table.partitions[numParts].data);
+
+            ++numParts;
+        }
+    }
+}
+
+const pnor_partition& Table::partition(size_t offset) const
+{
+    const decltype(auto) table = getNativeTable();
+    size_t offt = offset / block::size;
+
+    for (decltype(numParts) i{}; i < numParts; ++i)
+    {
+        if ((offt >= table.partitions[i].data.base) &&
+            (offt < (table.partitions[i].data.base +
+                     table.partitions[i].data.size)))
+        {
+            return table.partitions[i];
+        }
+    }
+
+    static pnor_partition p{};
+    return p;
+}
+
+} // namespace partition
+
+PartitionTable endianFixup(const PartitionTable& in)
+{
+    PartitionTable out;
+    out.resize(in.size());
+    auto src = reinterpret_cast<const pnor_partition_table*>(in.data());
+    auto dst = reinterpret_cast<pnor_partition_table*>(out.data());
+
+    dst->data.magic = htobe32(src->data.magic);
+    dst->data.version = htobe32(src->data.version);
+    dst->data.size = htobe32(src->data.size);
+    dst->data.entry_size = htobe32(src->data.entry_size);
+    dst->data.entry_count = htobe32(src->data.entry_count);
+    dst->data.block_size = htobe32(src->data.block_size);
+    dst->data.block_count = htobe32(src->data.block_count);
+    dst->checksum = htobe32(src->checksum);
+
+    for (decltype(src->data.entry_count) i{}; i < src->data.entry_count; ++i)
+    {
+        auto psrc = &src->partitions[i];
+        auto pdst = &dst->partitions[i];
+        strncpy(pdst->data.name, psrc->data.name, PARTITION_NAME_MAX);
+        // Just to be safe
+        pdst->data.name[PARTITION_NAME_MAX] = '\0';
+        pdst->data.base = htobe32(psrc->data.base);
+        pdst->data.size = htobe32(psrc->data.size);
+        pdst->data.pid = htobe32(psrc->data.pid);
+        pdst->data.id = htobe32(psrc->data.id);
+        pdst->data.type = htobe32(psrc->data.type);
+        pdst->data.flags = htobe32(psrc->data.flags);
+        pdst->data.actual = htobe32(psrc->data.actual);
+        for (size_t j = 0; j < PARTITION_USER_WORDS; ++j)
+        {
+            pdst->data.user.data[j] = htobe32(psrc->data.user.data[j]);
+        }
+        pdst->checksum = htobe32(psrc->checksum);
+    }
+
+    return out;
+}
+
+} // namespace virtual_pnor
+} // namespace openpower
diff --git a/pnor_partition_table.hpp b/pnor_partition_table.hpp
new file mode 100644
index 0000000..b6c50f4
--- /dev/null
+++ b/pnor_partition_table.hpp
@@ -0,0 +1,214 @@
+#pragma once
+
+#include <vector>
+#include <memory>
+#include <numeric>
+#include <experimental/filesystem>
+#include "pnor_partition_defs.h"
+
+namespace openpower
+{
+namespace virtual_pnor
+{
+
+namespace fs = std::experimental::filesystem;
+
+using PartitionTable = std::vector<uint8_t>;
+using checksum_t = uint32_t;
+
+/** @brief Convert the input partition table to big endian.
+ *
+ *  @param[in] src - reference to the pnor partition table
+ *
+ *  @returns converted partition table
+ */
+PartitionTable endianFixup(const PartitionTable& src);
+
+namespace details
+{
+
+/** @brief Compute XOR-based checksum, by XORing consecutive words
+ *         in the input data. Input must be aligned to word boundary.
+ *
+ *  @param[in] data - input data on which checksum is computed
+ *
+ *  @returns computed checksum
+ */
+template <class T>
+checksum_t checksum(const T& data)
+{
+    static_assert(sizeof(decltype(data)) % sizeof(checksum_t) == 0,
+                  "sizeof(data) is not aligned to sizeof(checksum_t) boundary");
+
+    auto begin = reinterpret_cast<const checksum_t*>(&data);
+    auto end = begin + (sizeof(decltype(data)) / sizeof(checksum_t));
+
+    return std::accumulate(begin, end, 0, std::bit_xor<checksum_t>());
+}
+
+} // namespace details
+
+namespace partition
+{
+
+/** @class Table
+ *  @brief Generates virtual PNOR partition table.
+ *
+ *  Generates virtual PNOR partition table upon construction. Reads
+ *  the PNOR information generated by this tool :
+ *  github.com/openbmc/openpower-pnor-code-mgmt/blob/master/generate-squashfs,
+ *  which generates a minimalistic table-of-contents (toc) file and
+ *  individual files to represent various partitions that are of interest -
+ *  these help form the "virtual" PNOR, which is typically a subset of the full
+ *  PNOR image.
+ *  These files are stored in a well-known location on the PNOR.
+ *  Based on this information, this class prepares the partition table whose
+ *  structure is as outlined in pnor_partition.h.
+ *
+ *  The virtual PNOR supports 4KB erase blocks - partitions must be aligned to
+ *  this size.
+ */
+class Table
+{
+    public:
+        /** @brief Constructor accepting the path of the directory
+         *         that houses the PNOR partition files.
+         *
+         *  @param[in] directory - path of the directory housing PNOR partitions
+         */
+        Table(fs::path&& directory);
+
+        Table();
+        Table(const Table&) = delete;
+        Table& operator=(const Table&) = delete;
+        Table(Table&&) = delete;
+        Table& operator=(Table&&) = delete;
+        ~Table() = default;
+
+        /** @brief Return size of partition table
+         *
+         *  @returns size_t - size of partition table in blocks
+         */
+        size_t size() const
+        {
+            return szBlocks;
+        }
+
+        /** @brief Return a partition table having byte-ordering
+         *         that the host expects.
+         *
+         *  The host needs the partion table in big-endian.
+         *
+         *  @returns const reference to host partition table.
+         */
+        const pnor_partition_table& getHostTable() const
+        {
+            return *(reinterpret_cast<
+                         const pnor_partition_table*>(hostTbl.data()));
+        }
+
+        /** @brief Return a little-endian partition table
+         *
+         *  @returns const reference to native partition table
+         */
+        const pnor_partition_table& getNativeTable() const
+        {
+            return *(reinterpret_cast<const pnor_partition_table*>(tbl.data()));
+        }
+
+        /** @brief Return partition corresponding to PNOR offset, the offset
+         *         is within returned partition.
+         *
+         *  @param[in] offset - PNOR offset in bytes
+         *
+         *  @returns const reference to pnor_partition, if found, else a
+         *           reference to a zeroed out pnor_partition structure.
+         */
+        const pnor_partition& partition(size_t offset) const;
+
+    private:
+        /** @brief Prepares a vector of PNOR partition structures.
+         */
+        void preparePartitions();
+
+        /** @brief Prepares the PNOR header.
+         */
+        void prepareHeader();
+
+        /** @brief Allocate memory to hold the partion table. Determine the
+         *         amount needed based on the partition files in the toc file.
+         *
+         *  @param[in] tocFile - Table of contents file path.
+         */
+        void allocateMemory(const fs::path& tocFile);
+
+        /** @brief Populate fields related to sizes for the input
+         *         pnor_partition structure.
+         *
+         *  @param[in/out] part - pnor_partition structure
+         *  @param[in] start - partition start address
+         *  @param[in] end - partition end address
+         */
+        void writeSizes(pnor_partition& part, size_t start, size_t end);
+
+        /** @brief Populate userdata bits for the input
+         *         pnor_partition structure.
+         *
+         *  @param[in/out] part - pnor_partition structure
+         *  @param[in] data - string having userdata fields in a
+         *             comma-separated line.
+         */
+        void writeUserdata(pnor_partition& part, const std::string& data);
+
+        /** @brief Populate the name and id fields for the input
+         *         pnor_partition structure.
+         *
+         *  @param[in/out] part - pnor_partition structure
+         *  @param[in] name - partition name
+         *  @param[id] id - partition id
+         */
+        void writeNameAndId(pnor_partition& part, std::string&& name,
+                            const std::string& id);
+
+        /** @brief Populate default/unused fields for the input
+         *         pnor_partition structure.
+         *
+         *  @param[in/out] part - pnor_partition structure
+         */
+        void writeDefaults(pnor_partition& part);
+
+        /** @brief Return a little-endian partition table
+         *
+         *  @returns reference to native partition table
+         */
+        pnor_partition_table& getNativeTable()
+        {
+            return *(reinterpret_cast<pnor_partition_table*>(tbl.data()));
+        }
+
+        /** @brief Size of the PNOR partition table -
+         *         sizeof(pnor_partition_table) +
+         *         (no. of partitions * sizeof(pnor_partition)),
+         *         measured in erase-blocks.
+         */
+        size_t szBlocks;
+
+        /** @brief Size of virtual PNOR image, measured in erase-blocks */
+        size_t imgBlocks;
+
+        /** @brief Partition table */
+        PartitionTable tbl;
+
+        /** @brief Partition table with host byte ordering */
+        PartitionTable hostTbl;
+
+        /** @brief Directory housing generated PNOR partition files */
+        fs::path directory;
+
+        /** @brief Number of partitions */
+        size_t numParts;
+};
+
+} // namespace partition
+} // namespace virtual_pnor
+} // namespace openpower
diff --git a/test/create_pnor_partition_table.cpp b/test/create_pnor_partition_table.cpp
new file mode 100644
index 0000000..bda443c
--- /dev/null
+++ b/test/create_pnor_partition_table.cpp
@@ -0,0 +1,76 @@
+#include "pnor_partition_table.hpp"
+#include "config.h"
+#include <assert.h>
+#include <string.h>
+#include <vector>
+#include <fstream>
+#include <experimental/filesystem>
+
+constexpr auto line = "partition01=HBB,00000000,00000400,ECC,PRESERVED";
+constexpr auto partitionName = "HBB";
+char tmplt[] = "/tmp/vpnor_partitions.XXXXXX";
+
+int main()
+{
+    namespace fs = std::experimental::filesystem;
+
+    char* tmpdir = mkdtemp(tmplt);
+    assert(tmpdir != nullptr);
+
+    fs::path tocFilePath{tmpdir};
+    tocFilePath /= PARTITION_TOC_FILE;
+    std::ofstream tocFile(tocFilePath.c_str());
+    tocFile.write(line, strlen(line));
+    tocFile.close();
+
+    fs::path partitionFilePath{tmpdir};
+    partitionFilePath /= partitionName;
+    std::ofstream partitionFile(partitionFilePath.c_str());
+    std::vector<char> empty(1, 0); // 1 byte file
+    partitionFile.write(empty.data(), empty.size());
+    partitionFile.close();
+
+    const openpower::virtual_pnor::partition::Table table(fs::path{tmpdir});
+
+    pnor_partition_table expectedTable{};
+    expectedTable.data.magic = PARTITION_HEADER_MAGIC;
+    expectedTable.data.version = PARTITION_VERSION_1;
+    expectedTable.data.size = 1; // 1 block
+    expectedTable.data.entry_size = sizeof(pnor_partition);
+    expectedTable.data.entry_count = 1; // 1 partition
+    expectedTable.data.block_size = 4096;
+    expectedTable.data.block_count = 2; // 1 table block and 1 partition block
+    expectedTable.checksum =
+        openpower::virtual_pnor::details::checksum(expectedTable.data);
+
+    pnor_partition expectedPartition{};
+    strcpy(expectedPartition.data.name, partitionName);
+    expectedPartition.data.base = 1; // starts after 1 block
+    expectedPartition.data.size = 1; // 1 block
+    expectedPartition.data.actual = 0x400; // 1024 bytes
+    expectedPartition.data.id = 1;
+    expectedPartition.data.pid = PARENT_PATITION_ID;
+    expectedPartition.data.type = PARTITION_TYPE_DATA;
+    expectedPartition.data.flags = 0;
+    expectedPartition.data.user.data[0] = PARTITION_ECC_PROTECTED;
+    expectedPartition.data.user.data[1] |= PARTITION_PRESERVED;
+    expectedPartition.checksum =
+        openpower::virtual_pnor::details::checksum(expectedPartition.data);
+
+    const pnor_partition_table& result = table.getNativeTable();
+
+    fs::remove_all(fs::path{tmpdir});
+
+    auto rc = memcmp(&expectedTable, &result, sizeof(pnor_partition_table));
+    assert(rc == 0);
+
+    rc = memcmp(&expectedPartition, &result.partitions[0],
+                sizeof(pnor_partition));
+    assert(rc == 0);
+
+    const pnor_partition& first = table.partition(4096);
+    rc = memcmp(&first, &result.partitions[0], sizeof(pnor_partition));
+    assert(rc == 0);
+
+    return 0;
+}