scs 0.5.6 → 0.6.0

data/vendor/scs/test/problems/test_validation.h

@@ -1,46 +1,285 @@
 #include "glbopts.h"
+#include "cones.h"
 #include "minunit.h"
 #include "problem_utils.h"
 #include "scs.h"
 #include "util.h"
 
+/* Shared minimal problem setup for validation tests. */
+static void _setup_validation_prob(ScsData *d, ScsCone *k, ScsSolution *opt,
+                                   int seed) {
+  scs_float p_f = 0.1;
+  scs_int n = 1, m = 3;
+  scs_int col_nnz = 1, nnz = 1;
+  k->z = (scs_int)(m * p_f);
+  k->l = m - k->z;
+  d->m = m;
+  d->n = n;
+  gen_random_prob_data(nnz, col_nnz, d, k, opt, seed);
+}
+
 static const char *test_validation(void) {
   scs_printf("Testing that SCS handles bad inputs correctly:\n");
 
-  ScsCone *k = (ScsCone *)scs_calloc(1, sizeof(ScsCone));
-  ScsData *d = (ScsData *)scs_calloc(1, sizeof(ScsData));
-  ScsSettings *stgs = (ScsSettings *)scs_calloc(1, sizeof(ScsSettings));
-  ScsSolution *sol = (ScsSolution *)scs_calloc(1, sizeof(ScsSolution));
-  ScsSolution *opt_sol = (ScsSolution *)scs_calloc(1, sizeof(ScsSolution));
+  ScsCone *k;
+  ScsData *d;
+  ScsSettings *stgs;
+  ScsSolution *sol, *opt_sol;
   ScsInfo info = {0};
-  scs_float p_f = 0.1;
-  int seed = 1234;
-  scs_int n = 1;
-  scs_int m = 3;
-  scs_int col_nnz = (scs_int)ceil(sqrt(n));
-  scs_int nnz = n * col_nnz;
   scs_int exitflag;
 
-  k->z = (scs_int)floor(m * p_f);
-  k->l = m - k->z;
+#define VALIDATION_SETUP()                                               \
+  do {                                                                   \
+    k = (ScsCone *)scs_calloc(1, sizeof(ScsCone));                       \
+    d = (ScsData *)scs_calloc(1, sizeof(ScsData));                       \
+    stgs = (ScsSettings *)scs_calloc(1, sizeof(ScsSettings));            \
+    sol = (ScsSolution *)scs_calloc(1, sizeof(ScsSolution));             \
+    opt_sol = (ScsSolution *)scs_calloc(1, sizeof(ScsSolution));         \
+    _setup_validation_prob(d, k, opt_sol, 1234);                         \
+    scs_set_default_settings(stgs);                                      \
+  } while (0)
 
-  d->m = m;
-  d->n = n;
-  gen_random_prob_data(nnz, col_nnz, d, k, opt_sol, seed);
-  scs_set_default_settings(stgs);
+#define VALIDATION_CLEANUP()                                             \
+  do {                                                                   \
+    SCS(free_data)(d);                                                   \
+    SCS(free_cone)(k);                                                   \
+    SCS(free_sol)(sol);                                                  \
+    SCS(free_sol)(opt_sol);                                              \
+    scs_free(stgs);                                                      \
+  } while (0)
 
-  /* TODO test more failure modes */
+  /* eps_abs < 0 */
+  VALIDATION_SETUP();
   stgs->eps_abs = -1;
+  exitflag = scs(d, k, stgs, sol, &info);
+  mu_assert("validation: eps_abs < 0 should fail", exitflag == SCS_FAILED);
+  VALIDATION_CLEANUP();
+
+  /* eps_abs NaN */
+  VALIDATION_SETUP();
+  stgs->eps_abs = NAN;
+  exitflag = scs(d, k, stgs, sol, &info);
+  mu_assert("validation: eps_abs NaN should fail", exitflag == SCS_FAILED);
+  VALIDATION_CLEANUP();
+
+  /* eps_rel < 0 */
+  VALIDATION_SETUP();
+  stgs->eps_rel = -1;
+  exitflag = scs(d, k, stgs, sol, &info);
+  mu_assert("validation: eps_rel < 0 should fail", exitflag == SCS_FAILED);
+  VALIDATION_CLEANUP();
+
+  /* eps_infeas < 0 */
+  VALIDATION_SETUP();
+  stgs->eps_infeas = -1;
+  exitflag = scs(d, k, stgs, sol, &info);
+  mu_assert("validation: eps_infeas < 0 should fail", exitflag == SCS_FAILED);
+  VALIDATION_CLEANUP();
+
+  /* max_iters <= 0 */
+  VALIDATION_SETUP();
+  stgs->max_iters = 0;
+  exitflag = scs(d, k, stgs, sol, &info);
+  mu_assert("validation: max_iters <= 0 should fail", exitflag == SCS_FAILED);
+  VALIDATION_CLEANUP();
+
+  /* alpha <= 0 */
+  VALIDATION_SETUP();
+  stgs->alpha = 0.0;
+  exitflag = scs(d, k, stgs, sol, &info);
+  mu_assert("validation: alpha <= 0 should fail", exitflag == SCS_FAILED);
+  VALIDATION_CLEANUP();
+
+  /* alpha >= 2 */
+  VALIDATION_SETUP();
+  stgs->alpha = 2.0;
+  exitflag = scs(d, k, stgs, sol, &info);
+  mu_assert("validation: alpha >= 2 should fail", exitflag == SCS_FAILED);
+  VALIDATION_CLEANUP();
+
+  /* rho_x <= 0 */
+  VALIDATION_SETUP();
+  stgs->rho_x = 0.0;
+  exitflag = scs(d, k, stgs, sol, &info);
+  mu_assert("validation: rho_x <= 0 should fail", exitflag == SCS_FAILED);
+  VALIDATION_CLEANUP();
+
+  /* scale <= 0 */
+  VALIDATION_SETUP();
+  stgs->scale = 0.0;
+  exitflag = scs(d, k, stgs, sol, &info);
+  mu_assert("validation: scale <= 0 should fail", exitflag == SCS_FAILED);
+  VALIDATION_CLEANUP();
+
+  /* time_limit_secs NaN */
+  VALIDATION_SETUP();
+  stgs->time_limit_secs = NAN;
+  exitflag = scs(d, k, stgs, sol, &info);
+  mu_assert("validation: time_limit_secs NaN should fail",
+            exitflag == SCS_FAILED);
+  VALIDATION_CLEANUP();
+
+  /* acceleration_interval <= 0 */
+  VALIDATION_SETUP();
+  stgs->acceleration_interval = 0;
+  exitflag = scs(d, k, stgs, sol, &info);
+  mu_assert("validation: acceleration_interval <= 0 should fail",
+            exitflag == SCS_FAILED);
+  VALIDATION_CLEANUP();
 
+  /* --- Cone validation tests --- */
+
+  /* cone dimension mismatch: total cone dims != m */
+  VALIDATION_SETUP();
+  k->l += 99; /* inflate l so total dims > m */
+  exitflag = scs(d, k, stgs, sol, &info);
+  mu_assert("validation: cone dims != m should fail", exitflag == SCS_FAILED);
+  VALIDATION_CLEANUP();
+
+  /* negative zero-cone dimension */
+  VALIDATION_SETUP();
+  k->l = 0;
+  k->z = -1;
+  d->m = -1; /* match total so cone-dims == m check passes */
   exitflag = scs(d, k, stgs, sol, &info);
+  mu_assert("validation: z < 0 should fail", exitflag == SCS_FAILED);
+  VALIDATION_CLEANUP();
+
+  /* box cone bl > bu */
+  {
+    scs_float bl_bad[] = {5.0};
+    scs_float bu_bad[] = {1.0};
+    VALIDATION_SETUP();
+    k->l = 0;
+    k->z = 0;
+    k->bsize = 2; /* 1 t-var + 1 bounded var */
+    k->bl = bl_bad;
+    k->bu = bu_bad;
+    d->m = 2;
+    exitflag = scs(d, k, stgs, sol, &info);
+    mu_assert("validation: bl > bu should fail", exitflag == SCS_FAILED);
+    k->bl = SCS_NULL; /* prevent double-free */
+    k->bu = SCS_NULL;
+    VALIDATION_CLEANUP();
+  }
+
+  /* box cone one-sided infinite bounds are valid */
+  {
+    ScsData d_box = {0};
+    ScsCone k_box = {0};
+    scs_float bl_inf[] = {-INFINITY, -1.0};
+    scs_float bu_inf[] = {1.0, INFINITY};
+    d_box.m = 3;
+    k_box.bsize = 3; /* 1 t-var + 2 bounded vars */
+    k_box.bl = bl_inf;
+    k_box.bu = bu_inf;
+    mu_assert("validation: box infinite bounds should pass",
+              SCS(validate_cones)(&d_box, &k_box) == 0);
+  }
+
+  /* box cone NaN bound */
+  {
+    ScsData d_box = {0};
+    ScsCone k_box = {0};
+    scs_float bl_nan[] = {NAN};
+    scs_float bu_nan[] = {1.0};
+    d_box.m = 2;
+    k_box.bsize = 2; /* 1 t-var + 1 bounded var */
+    k_box.bl = bl_nan;
+    k_box.bu = bu_nan;
+    mu_assert("validation: box NaN bound should fail",
+              SCS(validate_cones)(&d_box, &k_box) < 0);
+  }
+
+  /* box cone infinities must point in the valid bound direction */
+  {
+    ScsData d_box = {0};
+    ScsCone k_box = {0};
+    scs_float bl_bad_inf[] = {INFINITY};
+    scs_float bu_bad_inf[] = {INFINITY};
+    d_box.m = 2;
+    k_box.bsize = 2; /* 1 t-var + 1 bounded var */
+    k_box.bl = bl_bad_inf;
+    k_box.bu = bu_bad_inf;
+    mu_assert("validation: box +inf lower bound should fail",
+              SCS(validate_cones)(&d_box, &k_box) < 0);
+  }
+
+  /* power cone p out of range */
+  {
+    scs_float p_bad[] = {2.0}; /* must be in [-1, 1] */
+    VALIDATION_SETUP();
+    k->l = 0;
+    k->z = 0;
+    k->psize = 1;
+    k->p = p_bad;
+    d->m = 3;
+    exitflag = scs(d, k, stgs, sol, &info);
+    mu_assert("validation: p > 1 should fail", exitflag == SCS_FAILED);
+    k->p = SCS_NULL; /* prevent double-free */
+    VALIDATION_CLEANUP();
+  }
+
+  /* soc cone array missing */
+  VALIDATION_SETUP();
+  k->l = 0;
+  k->z = 0;
+  k->qsize = 1;
+  k->q = SCS_NULL;
+  d->m = 1;
+  exitflag = scs(d, k, stgs, sol, &info);
+  mu_assert("validation: missing soc cone array should fail",
+            exitflag == SCS_FAILED);
+  VALIDATION_CLEANUP();
 
-  mu_assert("test_fails: SCS failed to produce outputflag SCS_FAILED",
+  /* missing settings */
+  VALIDATION_SETUP();
+  exitflag = scs(d, k, SCS_NULL, sol, &info);
+  mu_assert("validation: missing settings should fail",
             exitflag == SCS_FAILED);
-  SCS(free_data)(d);
-  SCS(free_cone)(k);
-  SCS(free_sol)(sol);
-  SCS(free_sol)(opt_sol);
-  scs_free(stgs);
+  VALIDATION_CLEANUP();
+
+  /* missing A */
+  VALIDATION_SETUP();
+  SCS(free_scs_matrix)(d->A);
+  d->A = SCS_NULL;
+  exitflag = scs(d, k, stgs, sol, &info);
+  mu_assert("validation: missing A should fail", exitflag == SCS_FAILED);
+  VALIDATION_CLEANUP();
+
+  /* A dimensions inconsistent with ScsData */
+  VALIDATION_SETUP();
+  d->A->m = d->m + 1;
+  exitflag = scs(d, k, stgs, sol, &info);
+  mu_assert("validation: A dims inconsistent with data should fail",
+            exitflag == SCS_FAILED);
+  VALIDATION_CLEANUP();
+
+  /* A has negative row index */
+  VALIDATION_SETUP();
+  d->A->i[0] = -1;
+  exitflag = scs(d, k, stgs, sol, &info);
+  mu_assert("validation: A negative row index should fail",
+            exitflag == SCS_FAILED);
+  VALIDATION_CLEANUP();
+
+  /* A column pointers must be nondecreasing */
+  VALIDATION_SETUP();
+  d->A->p[0] = 1;
+  exitflag = scs(d, k, stgs, sol, &info);
+  mu_assert("validation: A invalid column pointer should fail",
+            exitflag == SCS_FAILED);
+  VALIDATION_CLEANUP();
+
+  /* A has non-finite data */
+  VALIDATION_SETUP();
+  d->A->x[0] = NAN;
+  exitflag = scs(d, k, stgs, sol, &info);
+  mu_assert("validation: A NaN entry should fail", exitflag == SCS_FAILED);
+  VALIDATION_CLEANUP();
+
+#undef VALIDATION_SETUP
+#undef VALIDATION_CLEANUP
 
   return 0;
 }

data/vendor/scs/test/problems/test_zero_cone.h

@@ -0,0 +1,81 @@
+#include "glbopts.h"
+#include "linalg.h"
+#include "minunit.h"
+#include "problem_utils.h"
+#include "scs.h"
+#include "util.h"
+
+/*
+ * Pure zero-cone problem: only equality constraints, no inequality cones.
+ * The zero-cone projection (src/cones.c) simply memsets the slice to 0.
+ *
+ * Problem: minimize x1 + x2
+ *          subject to x1 + x2 = 3
+ *                     x1 - x2 = 1
+ * Solution: x1 = 2, x2 = 1, obj = 3.
+ *
+ * Variables [x1, x2] (n=2), m=2, k->z=2 (only zero cone).
+ *
+ * A cols (CSC):
+ *   col 0 (x1): row 0 -> +1, row 1 -> +1
+ *   col 1 (x2): row 0 -> +1, row 1 -> -1
+ */
+static const char *test_zero_cone(void) {
+  ScsCone *k = (ScsCone *)scs_calloc(1, sizeof(ScsCone));
+  ScsData *d = (ScsData *)scs_calloc(1, sizeof(ScsData));
+  ScsSettings *stgs = (ScsSettings *)scs_calloc(1, sizeof(ScsSettings));
+  ScsSolution *sol = (ScsSolution *)scs_calloc(1, sizeof(ScsSolution));
+  ScsInfo info = {0};
+  scs_int exitflag;
+  scs_float perr, derr;
+  scs_int success;
+  const char *fail;
+
+  scs_float opt = 3.0;
+
+  scs_float Ax[] = {1.0, 1.0, 1.0, -1.0};
+  scs_int Ai[]   = {0, 1, 0, 1};
+  scs_int Ap[]   = {0, 2, 4};
+
+  scs_float b[] = {3.0, 1.0};
+  scs_float c[] = {1.0, 1.0};
+
+  scs_int m = 2, n = 2;
+
+  d->m = m;
+  d->n = n;
+  d->b = b;
+  d->c = c;
+
+  d->A = (ScsMatrix *)scs_calloc(1, sizeof(ScsMatrix));
+  d->A->m = m;
+  d->A->n = n;
+  d->A->x = Ax;
+  d->A->i = Ai;
+  d->A->p = Ap;
+
+  k->z = 2; /* only zero cone — no l, q, s, ep, ed, p */
+
+  scs_set_default_settings(stgs);
+  stgs->eps_abs = 1e-6;
+  stgs->eps_rel = 1e-6;
+
+  exitflag = scs(d, k, stgs, sol, &info);
+
+  perr = info.pobj - opt;
+  derr = info.dobj - opt;
+
+  scs_printf("primal obj error %4e\n", perr);
+  scs_printf("dual obj error %4e\n", derr);
+
+  success = ABS(perr) < 1e-4 && ABS(derr) < 1e-4 && exitflag == SCS_SOLVED;
+  mu_assert("test_zero_cone: SCS failed to produce SCS_SOLVED", success);
+  fail = verify_solution_correct(d, k, stgs, &info, sol, exitflag);
+
+  SCS(free_sol)(sol);
+  scs_free(d->A);
+  scs_free(k);
+  scs_free(stgs);
+  scs_free(d);
+  return fail;
+}

data/vendor/scs/test/problems/unbounded_lp.h

@@ -0,0 +1,66 @@
+#include "glbopts.h"
+#include "linalg.h"
+#include "minunit.h"
+#include "problem_utils.h"
+#include "scs.h"
+#include "util.h"
+
+/*
+ * Unbounded LP: min -x  s.t. x >= 0.
+ * x is unbounded above, so the objective -> -inf.
+ *
+ * SCS form: Ax + s = b, s in K_nn (l=1)
+ *   row 0: -x + s = 0, s >= 0  =>  s = x >= 0
+ *
+ * A = [[-1]], b = [0], c = [-1], k->l = 1.
+ */
+static const char *unbounded_lp(void) {
+  ScsCone *k = (ScsCone *)scs_calloc(1, sizeof(ScsCone));
+  ScsData *d = (ScsData *)scs_calloc(1, sizeof(ScsData));
+  ScsSettings *stgs = (ScsSettings *)scs_calloc(1, sizeof(ScsSettings));
+  ScsSolution *sol = (ScsSolution *)scs_calloc(1, sizeof(ScsSolution));
+  ScsInfo info = {0};
+  scs_int exitflag;
+  const char *fail;
+
+  scs_float Ax[] = {-1.0};
+  scs_int Ai[]   = {0};
+  scs_int Ap[]   = {0, 1};
+
+  scs_float b[] = {0.0};
+  scs_float c[] = {-1.0};
+
+  scs_int m = 1, n = 1;
+
+  d->m = m;
+  d->n = n;
+  d->b = b;
+  d->c = c;
+
+  d->A = (ScsMatrix *)scs_calloc(1, sizeof(ScsMatrix));
+  d->A->m = m;
+  d->A->n = n;
+  d->A->x = Ax;
+  d->A->i = Ai;
+  d->A->p = Ap;
+
+  k->l = m;
+
+  scs_set_default_settings(stgs);
+  stgs->eps_abs = 1e-6;
+  stgs->eps_rel = 1e-6;
+  stgs->eps_infeas = 1e-9;
+
+  exitflag = scs(d, k, stgs, sol, &info);
+
+  mu_assert("unbounded_lp: expected SCS_UNBOUNDED",
+            exitflag == SCS_UNBOUNDED);
+  fail = verify_solution_correct(d, k, stgs, &info, sol, exitflag);
+
+  SCS(free_sol)(sol);
+  scs_free(d->A);
+  scs_free(k);
+  scs_free(stgs);
+  scs_free(d);
+  return fail;
+}

data/vendor/scs/test/problems/unbounded_socp.h

@@ -0,0 +1,71 @@
+#include "glbopts.h"
+#include "linalg.h"
+#include "minunit.h"
+#include "problem_utils.h"
+#include "scs.h"
+#include "util.h"
+
+/*
+ * Unbounded SOCP: min -(t + x)  s.t.  (t, x) in SOC_2.
+ * On the boundary t = x >= 0, objective = -2t -> -inf.
+ *
+ * Variables [t, x] (n=2), m=2 (SOC_2):
+ *   row 0: -t + s0 = 0  => s0 = t
+ *   row 1: -x + s1 = 0  => s1 = x
+ *
+ * A cols (CSC):
+ *   col 0 (t): row 0 -> -1
+ *   col 1 (x): row 1 -> -1
+ */
+static const char *unbounded_socp(void) {
+  ScsCone *k = (ScsCone *)scs_calloc(1, sizeof(ScsCone));
+  ScsData *d = (ScsData *)scs_calloc(1, sizeof(ScsData));
+  ScsSettings *stgs = (ScsSettings *)scs_calloc(1, sizeof(ScsSettings));
+  ScsSolution *sol = (ScsSolution *)scs_calloc(1, sizeof(ScsSolution));
+  ScsInfo info = {0};
+  scs_int exitflag;
+  const char *fail;
+
+  scs_float Ax[] = {-1.0, -1.0};
+  scs_int Ai[]   = {0, 1};
+  scs_int Ap[]   = {0, 1, 2};
+
+  scs_float b[] = {0.0, 0.0};
+  scs_float c[] = {-1.0, -1.0};
+
+  scs_int q[] = {2};
+  scs_int m = 2, n = 2;
+
+  d->m = m;
+  d->n = n;
+  d->b = b;
+  d->c = c;
+
+  d->A = (ScsMatrix *)scs_calloc(1, sizeof(ScsMatrix));
+  d->A->m = m;
+  d->A->n = n;
+  d->A->x = Ax;
+  d->A->i = Ai;
+  d->A->p = Ap;
+
+  k->qsize = 1;
+  k->q = q;
+
+  scs_set_default_settings(stgs);
+  stgs->eps_abs = 1e-6;
+  stgs->eps_rel = 1e-6;
+  stgs->eps_infeas = 1e-9;
+
+  exitflag = scs(d, k, stgs, sol, &info);
+
+  mu_assert("unbounded_socp: expected SCS_UNBOUNDED",
+            exitflag == SCS_UNBOUNDED);
+  fail = verify_solution_correct(d, k, stgs, &info, sol, exitflag);
+
+  SCS(free_sol)(sol);
+  scs_free(d->A);
+  scs_free(k);
+  scs_free(stgs);
+  scs_free(d);
+  return fail;
+}

data/vendor/scs/test/run_from_file.c

@@ -1,7 +1,11 @@
 #include "rw.h"
+#include "cones.h"
 #include "scs.h"
 #include "util.h"
 
+#include <stdlib.h>
+#include <string.h>
+
 scs_int override_setting(ScsSettings *s, char *param, char *val) {
   scs_printf("Attempting to override %s with value %s.\n", param, val);
   if (strcmp(param, "normalize") == 0) {
@@ -28,6 +32,8 @@ scs_int override_setting(ScsSettings *s, char *param, char *val) {
     s->acceleration_interval = atoi(val);
   } else if (strcmp(param, "adaptive_scale") == 0) {
     s->adaptive_scale = atoi(val);
+  } else if (strcmp(param, "adaptive_diag_scale") == 0) {
+    s->adaptive_diag_scale = atoi(val);
   } else if (strcmp(param, "log_csv_filename") == 0) {
     s->log_csv_filename = val;
   } else {

data/vendor/scs/test/run_tests.c

@@ -7,12 +7,29 @@
 
 /* Include Tests */
 #include "problems/degenerate.h"
+#include "problems/dense_qp.h"
 #include "problems/hs21_tiny_qp.h"
+#include "problems/infeasible_lp.h"
+#include "problems/infeasible_socp.h"
 #include "problems/infeasible_tiny_qp.h"
+#include "problems/lp_update.h"
 #include "problems/qafiro_tiny_qp.h"
 #include "problems/small_lp.h"
 #include "problems/small_qp.h"
+#include "problems/test_dual_exp_cone.h"
 #include "problems/test_exp_cone.h"
+#include "problems/test_inaccurate.h"
+#include "problems/test_mixed_cones.h"
+#include "problems/test_normalize_roundtrip.h"
+#include "problems/test_power_cone.h"
+#include "problems/test_root_plus.h"
+#include "problems/test_soc_sizes.h"
+#include "problems/test_box_cone.h"
+#include "problems/test_psd_n1.h"
+#include "problems/test_solver_options.h"
+#include "problems/test_zero_cone.h"
+#include "problems/unbounded_lp.h"
+#include "problems/unbounded_socp.h"
 #include "problems/unbounded_tiny_qp.h"
 
 int tests_run = 0;
@@ -35,9 +52,11 @@ _SKIP(test_validation)
 #if defined(USE_LAPACK)
 #include "problems/complex_PSD.h"
 #include "problems/sd_and_complex_sd.h"
+#include "problems/test_psd_metric.h"
 #else
 _SKIP(complex_PSD)
 _SKIP(sd_and_complex_sd)
+_SKIP(test_psd_metric)
 #endif
 
 /* solve SDPs from data files, requires blas / lapack */
@@ -57,6 +76,8 @@ _SKIP(rob_gauss_cov_est)
 #include "spectral_cones_problems/several_logdet_cones.h"
 #include "spectral_cones_problems/several_nuc_cone.h"
 #include "spectral_cones_problems/several_sum_largest.h"
+#include "spectral_cones_problems/test_ell1_cone.h"
+#include "spectral_cones_problems/test_ell1_and_nuc.h"
 #else
 _SKIP(exp_design)
 _SKIP(robust_pca)
@@ -64,15 +85,19 @@ _SKIP(graph_partitioning)
 _SKIP(several_sum_largest)
 _SKIP(several_nuc_cone)
 _SKIP(several_logdet_cones)
+_SKIP(test_ell1_cone)
+_SKIP(test_ell1_and_nuc)
 #endif
 
 /* solves problems from data files */
 #if NO_READ_WRITE == 0
 #include "problems/hs21_tiny_qp_rw.h"
+#include "problems/test_rw_settings.h"
 #include "problems/max_ent.h"
 #include "problems/mpc_bug.h"
 #else
 _SKIP(hs21_tiny_qp_rw)
+_SKIP(test_rw_settings)
 _SKIP(max_ent)
 _SKIP(mpc_bug)
 #endif
@@ -80,26 +105,72 @@ _SKIP(mpc_bug)
 static const char *all_tests(void) {
   mu_run_test(test_validation);
   mu_run_test(degenerate);
+  mu_run_test(dense_qp);
   mu_run_test(small_lp);
   mu_run_test(small_qp);
+  mu_run_test(lp_update);
   mu_run_test(rob_gauss_cov_est);
   mu_run_test(complex_PSD);
   mu_run_test(sd_and_complex_sd);
+  mu_run_test(test_psd_metric);
   mu_run_test(hs21_tiny_qp);
   mu_run_test(hs21_tiny_qp_rw);
+  mu_run_test(test_rw_settings);
   mu_run_test(qafiro_tiny_qp);
   mu_run_test(infeasible_tiny_qp);
+  mu_run_test(infeasible_lp);
+  mu_run_test(infeasible_socp);
   mu_run_test(unbounded_tiny_qp);
+  mu_run_test(unbounded_lp);
+  mu_run_test(unbounded_socp);
   mu_run_test(random_prob);
   mu_run_test(max_ent);
   mu_run_test(mpc_bug);
   mu_run_test(test_exp_cone);
+  mu_run_test(test_dual_exp_cone);
+  mu_run_test(test_power_cone);
+  mu_run_test(test_power_cone_p09);
+  mu_run_test(test_dual_power_cone);
+  mu_run_test(test_multi_power);
+  mu_run_test(test_power_cone_infeasible);
+  mu_run_test(test_soc_size1);
+  mu_run_test(test_soc_size2);
+  mu_run_test(test_soc_size3);
+  mu_run_test(test_soc_size5);
+  mu_run_test(test_multi_soc);
+  mu_run_test(test_zero_cone);
+  mu_run_test(test_box_cone_lp);
+  mu_run_test(test_psd_n1);
+  mu_run_test(test_solved_inaccurate);
+  mu_run_test(test_infeasible_inaccurate);
+  mu_run_test(test_unbounded_inaccurate);
+  mu_run_test(test_max_iters_1);
+  mu_run_test(test_adaptive_scale);
+  mu_run_test(test_no_acceleration);
+  mu_run_test(test_type2_acceleration);
+  mu_run_test(test_aa_relaxation_sweep);
+  mu_run_test(test_aa_regularization_sweep);
+  mu_run_test(test_negative_lookback_rejected);
+  mu_run_test(test_invalid_aa_relaxation_rejected);
+  mu_run_test(test_pinned_negative_regularization_solves);
+  mu_run_test(test_invalid_aa_regularization_rejected);
+  mu_run_test(test_normalize_off);
+  mu_run_test(test_normalize_roundtrip);
+  mu_run_test(test_scs_version);
+  mu_run_test(test_time_limit_secs);
+  mu_run_test(test_warm_start);
+  mu_run_test(test_mixed_cones);
+  mu_run_test(test_root_plus_equivalence);
+  mu_run_test(test_normalize_roundtrip_lp);
+  mu_run_test(test_normalize_roundtrip_qp);
   mu_run_test(exp_design);
   mu_run_test(robust_pca);
   mu_run_test(graph_partitioning);
   mu_run_test(several_sum_largest);
   mu_run_test(several_nuc_cone);
   mu_run_test(several_logdet_cones);
+  mu_run_test(test_ell1_cone);
+  mu_run_test(test_ell1_and_nuc);
   return 0;
 }
 int main(void) {

data/vendor/scs/test/rw_settings.c

@@ -0,0 +1,7 @@
+#include "problems/test_rw_settings.h"
+
+int main(void) {
+  const char *result = test_rw_settings();
+  puts(result ? result : "rw_settings passed");
+  return result != SCS_NULL;
+}