kernel_fdt_test.cpp File Reference

#include "kernel_fdt.hpp"
#include <gtest/gtest.h>
#include "riscv64_virt.dtb.h"
#include "test_environment_state.hpp"

Include dependency graph for kernel_fdt_test.cpp:

Go to the source code of this file.

Classes
class	KernelFdtTest

Functions
	TEST_F (KernelFdtTest, ConstructorTest)
	TEST_F (KernelFdtTest, GetMemoryTest)
	TEST_F (KernelFdtTest, GetSerialTest)
	TEST_F (KernelFdtTest, GetTimebaseFrequencyTest)
	TEST_F (KernelFdtTest, GetCoreCountTest)
	TEST_F (KernelFdtTest, CopyConstructorTest)
	TEST_F (KernelFdtTest, AssignmentTest)
	TEST_F (KernelFdtTest, MoveConstructorTest)
	TEST_F (KernelFdtTest, MoveAssignmentTest)
	TEST_F (KernelFdtTest, ForEachCompatibleNodeTest)
	TEST_F (KernelFdtTest, ForEachNodeCompatibleDataTest)
	TEST_F (KernelFdtTest, ForEachCompatibleNodeNoMatchTest)
	TEST_F (KernelFdtTest, ForEachCompatibleNodeEarlyStopTest)
	TEST_F (KernelFdtTest, MultiCompatibleMatchTest)

Function Documentation

TEST_F() [1/14]

TEST_F	(	KernelFdtTest	,
		AssignmentTest
	)

Definition at line 87 of file kernel_fdt_test.cpp.

                                      {
  KernelFdt kerlen_fdt((uint64_t)riscv64_virt_dtb_data);
  KernelFdt kerlen_fdt2;
 
  kerlen_fdt2 = kerlen_fdt;
 
  auto result1 = kerlen_fdt.GetMemory();
  auto result2 = kerlen_fdt2.GetMemory();
 
  ASSERT_TRUE(result1.has_value());
  ASSERT_TRUE(result2.has_value());
 
  auto [memory_base1, memory_size1] = *result1;
  auto [memory_base2, memory_size2] = *result2;
 
  EXPECT_EQ(memory_base1, memory_base2);
  EXPECT_EQ(memory_size1, memory_size2);
}

Here is the call graph for this function:

TEST_F() [2/14]

TEST_F	(	KernelFdtTest	,
		ConstructorTest
	)

Definition at line 25 of file kernel_fdt_test.cpp.

                                       {
  KernelFdt kerlen_fdt((uint64_t)riscv64_virt_dtb_data);
}

TEST_F() [3/14]

TEST_F	(	KernelFdtTest	,
		CopyConstructorTest
	)

Definition at line 70 of file kernel_fdt_test.cpp.

                                           {
  KernelFdt kerlen_fdt((uint64_t)riscv64_virt_dtb_data);
  KernelFdt kerlen_fdt2(kerlen_fdt);
 
  auto result1 = kerlen_fdt.GetMemory();
  auto result2 = kerlen_fdt2.GetMemory();
 
  ASSERT_TRUE(result1.has_value());
  ASSERT_TRUE(result2.has_value());
 
  auto [memory_base1, memory_size1] = *result1;
  auto [memory_base2, memory_size2] = *result2;
 
  EXPECT_EQ(memory_base1, memory_base2);
  EXPECT_EQ(memory_size1, memory_size2);
}

Here is the call graph for this function:

TEST_F() [4/14]

TEST_F	(	KernelFdtTest	,
		ForEachCompatibleNodeEarlyStopTest
	)

Definition at line 212 of file kernel_fdt_test.cpp.

                                                          {
  KernelFdt kerlen_fdt((uint64_t)riscv64_virt_dtb_data);
 
  size_t count = 0;
  auto result = kerlen_fdt.ForEachCompatibleNode(
      "virtio,mmio",
      [&count](int offset, const char* node_name, uint64_t mmio_base,
               size_t mmio_size, uint32_t irq) -> bool {
        (void)offset;
        (void)node_name;
        (void)mmio_base;
        (void)mmio_size;
        (void)irq;
        ++count;
        return count < 3;  // Stop after 3 nodes
      });
  ASSERT_TRUE(result.has_value()) << result.error().message();
  EXPECT_EQ(count, 3);
}

Here is the call graph for this function:

TEST_F() [5/14]

TEST_F	(	KernelFdtTest	,
		ForEachCompatibleNodeNoMatchTest
	)

Definition at line 192 of file kernel_fdt_test.cpp.

                                                        {
  KernelFdt kerlen_fdt((uint64_t)riscv64_virt_dtb_data);
 
  size_t count = 0;
  auto result = kerlen_fdt.ForEachCompatibleNode(
      "nonexistent,device",
      [&count](int offset, const char* node_name, uint64_t mmio_base,
               size_t mmio_size, uint32_t irq) -> bool {
        (void)offset;
        (void)node_name;
        (void)mmio_base;
        (void)mmio_size;
        (void)irq;
        ++count;
        return true;
      });
  ASSERT_TRUE(result.has_value()) << result.error().message();
  EXPECT_EQ(count, 0);  // No matching nodes
}

Here is the call graph for this function:

TEST_F() [6/14]

TEST_F	(	KernelFdtTest	,
		ForEachCompatibleNodeTest
	)

Definition at line 139 of file kernel_fdt_test.cpp.

                                                 {
  KernelFdt kerlen_fdt((uint64_t)riscv64_virt_dtb_data);
 
  size_t count = 0;
  auto result = kerlen_fdt.ForEachCompatibleNode(
      "virtio,mmio",
      [&count](int offset, const char* node_name, uint64_t mmio_base,
               size_t mmio_size, uint32_t irq) -> bool {
        (void)offset;
        (void)node_name;
        (void)mmio_base;
        (void)mmio_size;
        (void)irq;
        ++count;
        return true;
      });
  ASSERT_TRUE(result.has_value()) << result.error().message();
  EXPECT_EQ(count, 8);  // riscv64 virt has 8 virtio,mmio nodes
}

Here is the call graph for this function:

TEST_F() [7/14]

TEST_F	(	KernelFdtTest	,
		ForEachNodeCompatibleDataTest
	)

Definition at line 159 of file kernel_fdt_test.cpp.

                                                     {
  KernelFdt kerlen_fdt((uint64_t)riscv64_virt_dtb_data);
 
  bool found_plic = false;
  auto result = kerlen_fdt.ForEachNode(
      [&found_plic](const char* node_name, const char* compatible_data,
                    size_t compatible_len, uint64_t mmio_base, size_t mmio_size,
                    uint32_t irq) -> bool {
        (void)mmio_base;
        (void)mmio_size;
        (void)irq;
        if (compatible_data == nullptr || compatible_len == 0) {
          return true;
        }
        // Look for PLIC node which has multi-string compatible:
        // "sifive,plic-1.0.0\0riscv,plic0"
        if (strcmp(node_name, "plic@c000000") == 0) {
          found_plic = true;
          // Should have both strings in the stringlist
          EXPECT_GT(compatible_len, strlen("sifive,plic-1.0.0") + 1);
          // First string should be "sifive,plic-1.0.0"
          EXPECT_STREQ(compatible_data, "sifive,plic-1.0.0");
          // Second string starts after first null terminator
          const char* second =
              compatible_data + strlen("sifive,plic-1.0.0") + 1;
          EXPECT_STREQ(second, "riscv,plic0");
        }
        return true;
      });
  ASSERT_TRUE(result.has_value()) << result.error().message();
  EXPECT_TRUE(found_plic) << "PLIC node not found in ForEachNode traversal";
}

Here is the call graph for this function:

TEST_F() [8/14]

TEST_F	(	KernelFdtTest	,
		GetCoreCountTest
	)

Definition at line 61 of file kernel_fdt_test.cpp.

                                        {
  KernelFdt kerlen_fdt((uint64_t)riscv64_virt_dtb_data);
 
  auto result = kerlen_fdt.GetCoreCount();
  ASSERT_TRUE(result.has_value()) << result.error().message();
 
  EXPECT_GT(*result, 0);  // 至少有一个 CPU 核心
}

Here is the call graph for this function:

TEST_F() [9/14]

TEST_F	(	KernelFdtTest	,
		GetMemoryTest
	)

Definition at line 29 of file kernel_fdt_test.cpp.

                                     {
  KernelFdt kerlen_fdt((uint64_t)riscv64_virt_dtb_data);
 
  auto result = kerlen_fdt.GetMemory();
  ASSERT_TRUE(result.has_value()) << result.error().message();
 
  auto [memory_base, memory_size] = *result;
  EXPECT_EQ(memory_base, 0x80000000);
  EXPECT_EQ(memory_size, 0x8000000);
}

Here is the call graph for this function:

TEST_F() [10/14]

TEST_F	(	KernelFdtTest	,
		GetSerialTest
	)

Definition at line 40 of file kernel_fdt_test.cpp.

                                     {
  KernelFdt kerlen_fdt((uint64_t)riscv64_virt_dtb_data);
 
  auto result = kerlen_fdt.GetSerial();
  ASSERT_TRUE(result.has_value()) << result.error().message();
 
  auto [serial_base, serial_size, serial_irq] = *result;
  EXPECT_EQ(serial_base, 0x10000000);
  EXPECT_EQ(serial_size, 0x100);
  EXPECT_EQ(serial_irq, 0xA);
}

Here is the call graph for this function:

TEST_F() [11/14]

TEST_F	(	KernelFdtTest	,
		GetTimebaseFrequencyTest
	)

Definition at line 52 of file kernel_fdt_test.cpp.

                                                {
  KernelFdt kerlen_fdt((uint64_t)riscv64_virt_dtb_data);
 
  auto result = kerlen_fdt.GetTimebaseFrequency();
  ASSERT_TRUE(result.has_value()) << result.error().message();
 
  EXPECT_EQ(*result, 0x989680);
}

Here is the call graph for this function:

TEST_F() [12/14]

TEST_F	(	KernelFdtTest	,
		MoveAssignmentTest
	)

Definition at line 122 of file kernel_fdt_test.cpp.

                                          {
  KernelFdt kerlen_fdt((uint64_t)riscv64_virt_dtb_data);
  auto result = kerlen_fdt.GetMemory();
  ASSERT_TRUE(result.has_value());
  auto [expected_base, expected_size] = *result;
 
  KernelFdt kerlen_fdt2;
  kerlen_fdt2 = std::move(kerlen_fdt);
 
  auto result2 = kerlen_fdt2.GetMemory();
  ASSERT_TRUE(result2.has_value());
  auto [memory_base, memory_size] = *result2;
 
  EXPECT_EQ(memory_base, expected_base);
  EXPECT_EQ(memory_size, expected_size);
}

Here is the call graph for this function:

TEST_F() [13/14]

TEST_F	(	KernelFdtTest	,
		MoveConstructorTest
	)

Definition at line 106 of file kernel_fdt_test.cpp.

                                           {
  KernelFdt kerlen_fdt((uint64_t)riscv64_virt_dtb_data);
  auto result = kerlen_fdt.GetMemory();
  ASSERT_TRUE(result.has_value());
  auto [expected_base, expected_size] = *result;
 
  KernelFdt kerlen_fdt2(std::move(kerlen_fdt));
 
  auto result2 = kerlen_fdt2.GetMemory();
  ASSERT_TRUE(result2.has_value());
  auto [memory_base, memory_size] = *result2;
 
  EXPECT_EQ(memory_base, expected_base);
  EXPECT_EQ(memory_size, expected_size);
}

Here is the call graph for this function:

TEST_F() [14/14]

TEST_F	(	KernelFdtTest	,
		MultiCompatibleMatchTest
	)

Definition at line 232 of file kernel_fdt_test.cpp.

                                                {
  KernelFdt kerlen_fdt((uint64_t)riscv64_virt_dtb_data);
 
  // The PLIC node has compatible = "sifive,plic-1.0.0\0riscv,plic0"
  // ForEachCompatibleNode uses fdt_node_offset_by_compatible which
  // matches against any string in the compatible stringlist
  size_t count = 0;
  auto result = kerlen_fdt.ForEachCompatibleNode(
      "riscv,plic0",
      [&count](int offset, const char* node_name, uint64_t mmio_base,
               size_t mmio_size, uint32_t irq) -> bool {
        (void)offset;
        (void)node_name;
        (void)mmio_base;
        (void)mmio_size;
        (void)irq;
        ++count;
        return true;
      });
  ASSERT_TRUE(result.has_value()) << result.error().message();
  EXPECT_EQ(count,
            1);  // Should find the PLIC node via second compatible string
}

Here is the call graph for this function: