Test the C++ generator in CI (2nd version: with more fixes included and more upstream changes)

.github/workflows/main.yml

@@ -59,7 +59,7 @@ jobs:
       matrix:
         os: [ubuntu-latest, macos-latest, windows-latest]
         # moonbit removed from language matrix for now - causing CI failures
-        lang: [c, rust, csharp]
+        lang: [c, rust, csharp, cpp]
         exclude:
           # For now csharp doesn't work on macos, so exclude it from testing.
           - os: macos-latest

crates/test/src/cpp.rs

@@ -41,11 +41,43 @@ impl LanguageMethods for Cpp {
 
     fn should_fail_verify(
         &self,
-        _name: &str,
+        name: &str,
         _config: &crate::config::WitConfig,
         _args: &[String],
     ) -> bool {
-        false
+        match name {
+            "async-trait-function.wit"
+            | "error-context.wit"
+            | "futures.wit"
+            | "import_export_func.wit"
+            | "import-func.wit"
+            | "issue573.wit"
+            | "issue929-no-export.wit"
+            | "keywords.wit"
+            | "lift-lower-foreign.wit"
+            | "lists.wit"
+            | "multiversion"
+            | "resource-alias.wit"
+            | "resource-borrow-in-record.wit"
+            | "resources.wit"
+            | "resources-in-aggregates.wit"
+            | "resources-with-futures.wit"
+            | "resources-with-streams.wit"
+            | "ret-areas.wit"
+            | "return-resource-from-export.wit"
+            | "same-names1.wit"
+            | "same-names5.wit"
+            | "simple-http.wit"
+            | "variants.wit"
+            | "variants-unioning-types.wit"
+            | "wasi-cli"
+            | "wasi-filesystem"
+            | "wasi-http"
+            | "wasi-io"
+            | "worlds-with-types.wit"
+            | "streams.wit" => true,
+            _ => false,
+        }
     }
 
     fn prepare(&self, runner: &mut crate::Runner<'_>) -> anyhow::Result<()> {
@@ -177,6 +209,13 @@ impl LanguageMethods for Cpp {
     }
 
     fn verify(&self, runner: &crate::Runner<'_>, verify: &crate::Verify) -> anyhow::Result<()> {
+        // for expected
+        let cwd = std::env::current_dir()?;
+        let mut helper_dir2 = cwd;
+        helper_dir2.push("crates");
+        helper_dir2.push("cpp");
+        helper_dir2.push("test_headers");
+
         let compiler = clangpp(runner);
         let mut cmd = Command::new(compiler);
         cmd.arg(
@@ -186,11 +225,14 @@ impl LanguageMethods for Cpp {
         )
         .arg("-I")
         .arg(&verify.bindings_dir)
+        .arg("-I")
+        .arg(helper_dir2.to_str().unwrap().to_string())
         .arg("-Wall")
         .arg("-Wextra")
         .arg("-Werror")
         .arg("-Wc++-compat")
         .arg("-Wno-unused-parameter")
+        .arg("-std=c++20")
         .arg("-c")
         .arg("-o")
         .arg(verify.artifacts_dir.join("tmp.o"));

tests/runtime/cpp/variant-with-data/runner.cpp

@@ -1,6 +1,8 @@
 #include <assert.h>
 #include <runner_cpp.h>
 
+using ::test::variant_with_data::to_test::DataVariant;
+
 template <class T>
 static bool equal(T const& a, T const& b) {
     return a == b;
@@ -19,12 +21,12 @@ static bool equal(wit::string const& a, wit::string const& b) {
     return a.get_view() == b.get_view();
 }
 
-static bool equal(::test::variant_with_data::to_test::DataVariant const& a, ::test::variant_with_data::to_test::DataVariant const& b) {
+static bool equal(DataVariant const& a, DataVariant const& b) {
     if (a.variants.index() != b.variants.index()) return false;
     switch (a.variants.index()) {
-        case 0: return equal(std::get<::test::variant_with_data::to_test::DataVariant::Bytes>(a.variants).value, std::get<::test::variant_with_data::to_test::DataVariant::Bytes>(b.variants).value);
-        case 1: return equal(std::get<::test::variant_with_data::to_test::DataVariant::Number>(a.variants).value, std::get<::test::variant_with_data::to_test::DataVariant::Number>(b.variants).value);
-        case 2: return equal(std::get<::test::variant_with_data::to_test::DataVariant::Text>(a.variants).value, std::get<::test::variant_with_data::to_test::DataVariant::Text>(b.variants).value);
+        case 0: return equal(std::get<DataVariant::Bytes>(a.variants).value, std::get<DataVariant::Bytes>(b.variants).value);
+        case 1: return equal(std::get<DataVariant::Number>(a.variants).value, std::get<DataVariant::Number>(b.variants).value);
+        case 2: return equal(std::get<DataVariant::Text>(a.variants).value, std::get<DataVariant::Text>(b.variants).value);
     }
     return false;
 }

tests/runtime/cpp/variant-with-data/test.cpp

@@ -2,21 +2,25 @@
 #include <vector>
 #include <test_cpp.h>
 
-using ::test::variant_with_data::to_test::DataVariant;
+using exports::test::variant_with_data::to_test::DataVariant;
 
 DataVariant exports::test::variant_with_data::to_test::GetData(uint8_t num) {
   DataVariant variant;
   switch (num) {
     case 0: {
       uint8_t bytes[]{0x01, 0x02, 0x03, 0x04, 0x05};
       variant.variants = DataVariant::Bytes(wit::vector<uint8_t>::from_view(std::span<uint8_t>(bytes)));
+      break;
     }
     case 1:
       variant.variants = DataVariant::Number(42);
+      break;
     case 2:
       variant.variants = DataVariant::Text(wit::string::from_view("hello"));
+      break;
     default:
       variant.variants = DataVariant::Number(0);
+      break;
   }
   auto result = std::move(variant);
   return result;

tests/runtime/resource_borrow_in_record/cpp/exports-test-resource_borrow_in_record-to_test-Thing.h

@@ -16,12 +16,16 @@ class Thing : public wit::ResourceExportBase<Thing> {
 public:
   static void Dtor(to_test::Thing *self) { delete self; }
   Thing(wit::string s) : contents(s.to_string()) {}
-  static Owned New(wit::string s) { return Owned(new Thing(std::move(s))); }
-  wit::string Get() const { return wit::string::from_view(std::string_view(contents)); }
+  static Owned New(wit::string s) { return Owned(new Thing(wit::string::from_view(std::string_view(s.to_string() + " new")))); }
+  wit::string Get() const { return wit::string::from_view(std::string_view(contents + " get")); }
   static int32_t ResourceNew(to_test::Thing *self);
   static Thing *ResourceRep(int32_t id);
   static void ResourceDrop(int32_t id);
 
+  // this is ugly but exactly how the Rust test is designed
+  static Owned new_internal(wit::string s) { return Owned(new Thing(std::move(s))); }
+  std::string const& get_internal() const { return contents; }
+
 private:
   std::string contents;
 };

tests/runtime/resource_borrow_in_record/test.cpp

@@ -5,8 +5,8 @@ namespace test_exports = ::exports::test::resource_borrow_in_record::to_test;
 wit::vector<test_exports::Thing::Owned> test_exports::Test(wit::vector<test_exports::Foo> list) {
     auto result = wit::vector<test_exports::Thing::Owned>::allocate(list.size()); 
     for (size_t i = 0; i < list.size(); ++i) {
-        auto str = wit::string::from_view(std::string_view(list[i].thing.get().Get().to_string() + " test"));
-        result.initialize(i, test_exports::Thing::New(std::move(str)));
+        auto str = wit::string::from_view(std::string_view(list[i].thing.get().get_internal() + " test"));
+        result.initialize(i, test_exports::Thing::new_internal(std::move(str)));
     }
     return result;
 }