Fix macos bundled link & improve tested example

.github/workflows/build_and_test.yml

@@ -14,7 +14,7 @@ jobs:
       matrix:
         os: [
           ubuntu-latest,
-          macos-latest,
+          macos-13,
           macos-14, # macOS arm runner
           windows-latest,
         ]
@@ -32,7 +32,7 @@ jobs:
       matrix:
         os: [
           ubuntu-latest,
-          macos-latest,
+          macos-13,
           macos-14, # macOS arm runner
           windows-latest,
         ]
@@ -49,7 +49,7 @@ jobs:
     strategy:
       matrix:
         os: [
-          macos-latest,
+          macos-13,
           macos-14,
           ubuntu-latest,
           windows-latest,
@@ -58,7 +58,7 @@ jobs:
     steps:
       - uses: actions/checkout@v3
       - name: Install bison
-        if: ${{ matrix.os == 'macos-latest' || matrix.os == 'macos-14' }}
+        if: ${{ matrix.os == 'macos-13' || matrix.os == 'macos-14' }}
         run: |
           brew install bison gcc
       - name: Test from-source

bundled.rs

@@ -27,7 +27,7 @@ pub fn download_scip() {
     let os_string = if os == "linux" && arch == "x86_64" {
         "linux"
     } else if os == "macos" && arch == "x86_64" {
-        "macos"
+        "macos-intel"
     } else if os == "macos" && arch == "aarch64" {
         "macos-arm"
     } else if os == "windows" && arch == "x86_64" {

examples/create.rs

@@ -1,10 +1,56 @@
-use scip_sys::{SCIPcreate, SCIPfree, SCIPprintVersion};
+use scip_sys::*;
 use std::mem::MaybeUninit;
 
 fn main() {
     let mut scip_ptr = MaybeUninit::uninit();
     unsafe { SCIPcreate(scip_ptr.as_mut_ptr()) };
     let mut scip_ptr = unsafe { scip_ptr.assume_init() };
-    unsafe { SCIPprintVersion(scip_ptr, std::ptr::null_mut()) };
+
+    // include default plugins
+    unsafe { SCIPincludeDefaultPlugins(scip_ptr) };
+
+    unsafe { SCIPcreateProbBasic(scip_ptr, "test".as_ptr() as *const i8) };
+
+    // add a variable
+    let mut var_ptr = MaybeUninit::uninit();
+    unsafe {
+        SCIPcreateVarBasic(
+            scip_ptr,
+            var_ptr.as_mut_ptr(),
+            "x".as_ptr() as *const i8,
+            0.0,
+            1.0,
+            1.0,
+            SCIP_Vartype_SCIP_VARTYPE_BINARY,
+        )
+    };
+    let mut var_ptr = unsafe { var_ptr.assume_init() };
+    unsafe { SCIPaddVar(scip_ptr, var_ptr) };
+
+    // add a constraint
+    let mut cons_ptr = MaybeUninit::uninit();
+    unsafe {
+        SCIPcreateConsBasicLinear(
+            scip_ptr,
+            cons_ptr.as_mut_ptr(),
+            "c".as_ptr() as *const i8,
+            1,
+            &mut var_ptr,
+            &mut 1.0,
+            1.0,
+            1.0,
+        )
+    };
+    let mut cons_ptr = unsafe { cons_ptr.assume_init() };
+    unsafe { SCIPaddCons(scip_ptr, cons_ptr) };
+
+    unsafe { SCIPsolve(scip_ptr) };
+
+    let obj_val = unsafe { SCIPgetPrimalbound(scip_ptr) };
+    let eps = unsafe { SCIPfeastol(scip_ptr) };
+    assert!((obj_val - 1.0).abs() < eps);
+
+    unsafe { SCIPreleaseVar(scip_ptr, &mut var_ptr) };
+    unsafe { SCIPreleaseCons(scip_ptr, &mut cons_ptr) };
     unsafe { SCIPfree(&mut scip_ptr) };
 }

from_source.rs

@@ -60,6 +60,6 @@ pub fn compile_scip(source_path: PathBuf) -> PathBuf {
 }
 
 #[cfg(not(feature = "from-source"))]
-pub fn compile_scip(source_path: PathBuf) -> PathBuf {
+pub fn compile_scip(_source_path: PathBuf) -> PathBuf {
     unimplemented!("Cannot compile SCIP without the `from-source` feature")
 }

src/lib.rs

@@ -18,6 +18,53 @@ mod tests {
         let mut scip_ptr = MaybeUninit::uninit();
         unsafe { SCIPcreate(scip_ptr.as_mut_ptr()) };
         let mut scip_ptr = unsafe { scip_ptr.assume_init() };
+
+        // include default plugins
+        unsafe { SCIPincludeDefaultPlugins(scip_ptr) };
+
+        unsafe { SCIPcreateProbBasic(scip_ptr, "test".as_ptr() as *const i8) };
+
+        // add a variable
+        let mut var_ptr = MaybeUninit::uninit();
+        unsafe {
+            SCIPcreateVarBasic(
+                scip_ptr,
+                var_ptr.as_mut_ptr(),
+                "x".as_ptr() as *const i8,
+                0.0,
+                1.0,
+                1.0,
+                SCIP_Vartype_SCIP_VARTYPE_BINARY,
+            )
+        };
+        let mut var_ptr = unsafe { var_ptr.assume_init() };
+        unsafe { SCIPaddVar(scip_ptr, var_ptr) };
+
+        // add a constraint
+        let mut cons_ptr = MaybeUninit::uninit();
+        unsafe {
+            SCIPcreateConsBasicLinear(
+                scip_ptr,
+                cons_ptr.as_mut_ptr(),
+                "c".as_ptr() as *const i8,
+                1,
+                &mut var_ptr,
+                &mut 1.0,
+                1.0,
+                1.0,
+            )
+        };
+        let mut cons_ptr = unsafe { cons_ptr.assume_init() };
+        unsafe { SCIPaddCons(scip_ptr, cons_ptr) };
+
+        unsafe { SCIPsolve(scip_ptr) };
+
+        let obj_val = unsafe { SCIPgetPrimalbound(scip_ptr) };
+        let eps = unsafe { SCIPfeastol(scip_ptr) };
+        assert!((obj_val - 1.0).abs() < eps);
+
+        unsafe { SCIPreleaseVar(scip_ptr, &mut var_ptr) };
+        unsafe { SCIPreleaseCons(scip_ptr, &mut cons_ptr) };
         unsafe { SCIPfree(&mut scip_ptr) };
     }
 }