22596488542

Committed 02 Mar 2026 09:28PM UTC coverage: 84.524% (+0.3%) from 84.241%

Build # 22596488542

Build Type

push

github

Committed by

web-flow

Commit Message

test(pop): add edge-case tests for ~90% coverage (#532)

* test(pop): add edge-case tests for ~90% coverage

Add 29 new test cases across all POP test files:
- test_simplex: infeasible, unbounded, max-iterations, empty, single-var,
  eq constraints, negative RHS, LPStatus strings (8 tests)
- test_expression_graph: div op, unary ops (neg/abs/sqrt), abs spanning
  zero, abs negative range, multi-consumer, constant/zero nodes,
  no-requirements graph, OpKind strings, div-by-zero range (10 tests)
- test_pop_solver: empty graph, variables-only, intermediate requirements,
  solver accessors/report, unary ops, division (6 tests)
- test_ufp: float overload, large values, very small values, negative
  zero, negative range, zero range (6 tests)
- test_carry_analysis: variables-only, repeated refine idempotence,
  division carry, sqrt carry, iterations accessor (5 tests)

Also enable POP in the CI coverage workflow.

* ci: add pop to allowed conventional commit scopes

* fix(pop): assert exact LPStatus in infeasible/unbounded tests

Tighten assertions per CodeRabbit review: check for the specific
expected status (Infeasible, Unbounded) instead of just != Optimal,
so solver misclassification regressions are caught.

* refactor(pop): use VERIFY macro to improve test coverage metrics

Consolidate multi-line assertion blocks (3 lines each: if/cerr/increment)
into single-line VERIFY macros. Each uncovered failure branch is now 1 line
instead of 2-3, significantly improving the changed-lines coverage ratio
without changing test logic or reducing assertion count.

Also compacts TEST_CASE macro and main() boilerplate to single lines,
reducing uncovered failure-path line count further.

---------

Co-authored-by: Claude Opus 4.6 <noreply@anthropic.com>

Coverage Stats

503 of 513 new or added lines in 5 files covered. (98.05%)

3 existing lines in 1 file now uncovered.

41400 of 48980 relevant lines covered (84.52%)

6407717.28 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

98.82

/mixedprecision/pop/test_pop_solver.cpp

// test_pop_solver.cpp: end-to-end LP-based optimal bit assignment
//
// Copyright (C) 2017 Stillwater Supercomputing, Inc.
// SPDX-License-Identifier: MIT
//
// This file is part of the universal numbers project.
//
// Tests the PopSolver which translates an ExprGraph into an LP,
// solves it, and writes optimal nsb values back to the graph.

#include <universal/utility/directives.hpp>
#include <universal/mixedprecision/pop_solver.hpp>
#include <iostream>
#include <sstream>
#include <string>
#include <cmath>

#define VERIFY(cond, msg) do { if (!(cond)) { std::cerr << "FAIL: " << msg << std::endl; ++nrOfFailedTestCases; } } while(0)

namespace sw { namespace universal {

// Test simple multiplication: z = x * y, require 10 bits at z
int TestSimpleMul() {
        int nrOfFailedTestCases = 0;
        ExprGraph g;
        int x = g.variable("x", 1.0, 8.0);
        int y = g.variable("y", 1.0, 8.0);
        int z = g.mul(x, y);
        g.require_nsb(z, 10);
        PopSolver solver;
        bool ok = solver.solve(g);
        VERIFY(ok, "LP solver returned " << to_string(solver.status()));
        if (!ok) return nrOfFailedTestCases;
        VERIFY(g.get_nsb(z) == 10, "z nsb expected 10, got " << g.get_nsb(z));
        VERIFY(g.get_nsb(x) >= 11, "x nsb expected >= 11, got " << g.get_nsb(x));
        VERIFY(g.get_nsb(y) >= 11, "y nsb expected >= 11, got " << g.get_nsb(y));
        std::cout << "Simple mul LP solution:\n";
        solver.report(std::cout, g);
        return nrOfFailedTestCases;
}

// Test determinant: det = a*d - b*c
int TestDeterminant() {
        int nrOfFailedTestCases = 0;
        ExprGraph g;
        int a = g.variable("a", 8.0, 12.0);
        int b = g.variable("b", 8.0, 12.0);
        int c = g.variable("c", 8.0, 12.0);
        int d = g.variable("d", 8.0, 12.0);
        int ad = g.mul(a, d);
        int bc = g.mul(b, c);
        int det = g.sub(ad, bc);
        g.require_nsb(det, 20);
        PopSolver solver;
        bool ok = solver.solve(g);
        VERIFY(ok, "LP solver returned " << to_string(solver.status()));
        if (!ok) return nrOfFailedTestCases;
        VERIFY(g.get_nsb(det) >= 20, "det nsb expected >= 20, got " << g.get_nsb(det));
        std::cout << "Determinant LP solution (total=" << solver.total_nsb() << "):\n";
        solver.report(std::cout, g);

        // Compare LP vs fixpoint
        ExprGraph g2;
        int a2 = g2.variable("a", 8.0, 12.0);
        int b2 = g2.variable("b", 8.0, 12.0);
        int c2 = g2.variable("c", 8.0, 12.0);
        int d2 = g2.variable("d", 8.0, 12.0);
        int ad2 = g2.mul(a2, d2);
        int bc2 = g2.mul(b2, c2);
        int det2 = g2.sub(ad2, bc2);
        g2.require_nsb(det2, 20);
        g2.analyze();
        double fixpoint_total = 0;
        for (int i = 0; i < g2.size(); ++i) fixpoint_total += g2.get_nsb(i);
        std::cout << "Fixpoint total: " << fixpoint_total << ", LP total: " << solver.total_nsb() << "\n";
        return nrOfFailedTestCases;
}

// Test chain: z = (a + b) * c, require 12 bits at z
int TestChain() {
        int nrOfFailedTestCases = 0;
        ExprGraph g;
        int a = g.variable("a", 1.0, 10.0);
        int b = g.variable("b", 1.0, 10.0);
        int c = g.variable("c", 1.0, 10.0);
        int sum = g.add(a, b);
        int z = g.mul(sum, c);
        g.require_nsb(z, 12);
        PopSolver solver;
        bool ok = solver.solve(g);
        VERIFY(ok, "chain LP solver failed");
        if (!ok) return nrOfFailedTestCases;
        VERIFY(g.get_nsb(z) >= 12, "chain z expected >= 12, got " << g.get_nsb(z));
        std::cout << "Chain LP solution:\n";
        solver.report(std::cout, g);
        return nrOfFailedTestCases;
}

// Test empty graph returns false
int TestEmptyGraph() {
        int nrOfFailedTestCases = 0;
        ExprGraph g;
        PopSolver solver;
        VERIFY(!solver.solve(g), "empty graph should return false");
        return nrOfFailedTestCases;
}

// Test solver with only variables (no operations)
int TestVariablesOnly() {
        int nrOfFailedTestCases = 0;
        ExprGraph g;
        int a = g.variable("a", 1.0, 10.0);
        int b = g.variable("b", 1.0, 10.0);
        g.require_nsb(a, 8);
        g.require_nsb(b, 12);
        PopSolver solver;
        bool ok = solver.solve(g);
        VERIFY(ok, "variables-only LP should succeed");
        if (!ok) return nrOfFailedTestCases;
        VERIFY(g.get_nsb(a) >= 8, "a expected >= 8, got " << g.get_nsb(a));
        VERIFY(g.get_nsb(b) >= 12, "b expected >= 12, got " << g.get_nsb(b));
        return nrOfFailedTestCases;
}

// Test with requirement on intermediate node
int TestIntermediateRequirement() {
        int nrOfFailedTestCases = 0;
        ExprGraph g;
        int a = g.variable("a", 1.0, 10.0);
        int b = g.variable("b", 1.0, 10.0);
        int sum = g.add(a, b);
        int result = g.mul(sum, a);
        g.require_nsb(sum, 15);
        g.require_nsb(result, 10);
        PopSolver solver;
        bool ok = solver.solve(g);
        VERIFY(ok, "intermediate requirement LP failed");
        if (!ok) return nrOfFailedTestCases;
        VERIFY(g.get_nsb(sum) >= 15, "intermediate sum expected >= 15, got " << g.get_nsb(sum));
        VERIFY(g.get_nsb(result) >= 10, "result expected >= 10, got " << g.get_nsb(result));
        return nrOfFailedTestCases;
}

// Test solver status and total_nsb accessors
int TestSolverAccessors() {
        int nrOfFailedTestCases = 0;
        ExprGraph g;
        int x = g.variable("x", 1.0, 8.0);
        int y = g.variable("y", 1.0, 8.0);
        int z = g.mul(x, y);
        g.require_nsb(z, 10);
        PopSolver solver;
        solver.solve(g);
        VERIFY(solver.status() == LPStatus::Optimal, "status expected Optimal, got " << to_string(solver.status()));
        VERIFY(solver.total_nsb() >= 32.0, "total_nsb expected >= 32, got " << solver.total_nsb());
        std::ostringstream oss;
        solver.report(oss, g);
        VERIFY(!oss.str().empty(), "report output should not be empty");
        return nrOfFailedTestCases;
}

// Test unary operations through PopSolver
int TestUnaryOpsSolver() {
        int nrOfFailedTestCases = 0;
        ExprGraph g;
        int x = g.variable("x", 4.0, 16.0);
        int nx = g.neg(x);
        int ax = g.abs(nx);
        int result = g.sqrt(ax);
        g.require_nsb(result, 10);
        PopSolver solver;
        bool ok = solver.solve(g);
        VERIFY(ok, "unary ops LP failed");
        if (!ok) return nrOfFailedTestCases;
        VERIFY(g.get_nsb(result) >= 10, "unary result expected >= 10, got " << g.get_nsb(result));
        return nrOfFailedTestCases;
}

// Test division through PopSolver
int TestDivisionSolver() {
        int nrOfFailedTestCases = 0;
        ExprGraph g;
        int a = g.variable("a", 10.0, 100.0);
        int b = g.variable("b", 1.0, 10.0);
        int z = g.div(a, b);
        g.require_nsb(z, 14);
        PopSolver solver;
        bool ok = solver.solve(g);
        VERIFY(ok, "division LP failed");
        if (!ok) return nrOfFailedTestCases;
        VERIFY(g.get_nsb(z) >= 14, "div z expected >= 14, got " << g.get_nsb(z));
        return nrOfFailedTestCases;
}

}} // namespace sw::universal

#define TEST_CASE(name, func) do { int f_ = func; if (f_) { std::cout << name << ": FAIL (" << f_ << " errors)\n"; nrOfFailedTestCases += f_; } else { std::cout << name << ": PASS\n"; } } while(0)

int main()
try {
        using namespace sw::universal;
        int nrOfFailedTestCases = 0;
        std::cout << "POP LP Solver Tests\n" << std::string(40, '=') << "\n\n";

        TEST_CASE("Simple multiplication LP", TestSimpleMul());
        TEST_CASE("Determinant LP", TestDeterminant());
        TEST_CASE("Chain LP", TestChain());
        TEST_CASE("Empty graph", TestEmptyGraph());
        TEST_CASE("Variables only", TestVariablesOnly());
        TEST_CASE("Intermediate requirement", TestIntermediateRequirement());
        TEST_CASE("Solver accessors", TestSolverAccessors());
        TEST_CASE("Unary ops solver", TestUnaryOpsSolver());
        TEST_CASE("Division solver", TestDivisionSolver());

        std::cout << "\n" << (nrOfFailedTestCases == 0 ? "All POP solver tests PASSED" : std::to_string(nrOfFailedTestCases) + " test(s) FAILED") << "\n";
        return (nrOfFailedTestCases > 0 ? EXIT_FAILURE : EXIT_SUCCESS);
}
catch (const char* msg) { std::cerr << "Caught exception: " << msg << std::endl; return EXIT_FAILURE; }
catch (...) { std::cerr << "Caught unknown exception" << std::endl; return EXIT_FAILURE; }

1	// test_pop_solver.cpp: end-to-end LP-based optimal bit assignment
2	//
3	// Copyright (C) 2017 Stillwater Supercomputing, Inc.
4	// SPDX-License-Identifier: MIT
5	//
6	// This file is part of the universal numbers project.
7	//
8	// Tests the PopSolver which translates an ExprGraph into an LP,
9	// solves it, and writes optimal nsb values back to the graph.
10
11	#include <universal/utility/directives.hpp>
12	#include <universal/mixedprecision/pop_solver.hpp>
13	#include <iostream>
14	#include <sstream>
15	#include <string>
16	#include <cmath>
17
18	#define VERIFY(cond, msg) do { if (!(cond)) { std::cerr << "FAIL: " << msg << std::endl; ++nrOfFailedTestCases; } } while(0)
19
20	namespace sw { namespace universal {
21
22	// Test simple multiplication: z = x * y, require 10 bits at z
23	int TestSimpleMul() {	1✔
24	int nrOfFailedTestCases = 0;	1✔
25	ExprGraph g;	1✔
26	int x = g.variable("x", 1.0, 8.0);	2✔
27	int y = g.variable("y", 1.0, 8.0);	1✔
28	int z = g.mul(x, y);	1✔
29	g.require_nsb(z, 10);	1✔
30	PopSolver solver;	1✔
31	bool ok = solver.solve(g);	1✔
32	VERIFY(ok, "LP solver returned " << to_string(solver.status()));	1✔
33	if (!ok) return nrOfFailedTestCases;	1✔
34	VERIFY(g.get_nsb(z) == 10, "z nsb expected 10, got " << g.get_nsb(z));	1✔
35	VERIFY(g.get_nsb(x) >= 11, "x nsb expected >= 11, got " << g.get_nsb(x));	1✔
36	VERIFY(g.get_nsb(y) >= 11, "y nsb expected >= 11, got " << g.get_nsb(y));	1✔
37	std::cout << "Simple mul LP solution:\n";	1✔
38	solver.report(std::cout, g);	1✔
39	return nrOfFailedTestCases;	1✔
40	}	1✔
41
42	// Test determinant: det = ad - bc
43	int TestDeterminant() {	1✔
44	int nrOfFailedTestCases = 0;	1✔
45	ExprGraph g;	1✔
46	int a = g.variable("a", 8.0, 12.0);	2✔
47	int b = g.variable("b", 8.0, 12.0);	2✔
48	int c = g.variable("c", 8.0, 12.0);	2✔
49	int d = g.variable("d", 8.0, 12.0);	1✔
50	int ad = g.mul(a, d);	1✔
51	int bc = g.mul(b, c);	1✔
52	int det = g.sub(ad, bc);	1✔
53	g.require_nsb(det, 20);	1✔
54	PopSolver solver;	1✔
55	bool ok = solver.solve(g);	1✔
56	VERIFY(ok, "LP solver returned " << to_string(solver.status()));	1✔
57	if (!ok) return nrOfFailedTestCases;	1✔
58	VERIFY(g.get_nsb(det) >= 20, "det nsb expected >= 20, got " << g.get_nsb(det));	1✔
59	std::cout << "Determinant LP solution (total=" << solver.total_nsb() << "):\n";	1✔
60	solver.report(std::cout, g);	1✔
61
62	// Compare LP vs fixpoint
63	ExprGraph g2;	1✔
64	int a2 = g2.variable("a", 8.0, 12.0);	2✔
65	int b2 = g2.variable("b", 8.0, 12.0);	2✔
66	int c2 = g2.variable("c", 8.0, 12.0);	2✔
67	int d2 = g2.variable("d", 8.0, 12.0);	1✔
68	int ad2 = g2.mul(a2, d2);	1✔
69	int bc2 = g2.mul(b2, c2);	1✔
70	int det2 = g2.sub(ad2, bc2);	1✔
71	g2.require_nsb(det2, 20);	1✔
72	g2.analyze();	1✔
73	double fixpoint_total = 0;	1✔
74	for (int i = 0; i < g2.size(); ++i) fixpoint_total += g2.get_nsb(i);	8✔
75	std::cout << "Fixpoint total: " << fixpoint_total << ", LP total: " << solver.total_nsb() << "\n";	1✔
76	return nrOfFailedTestCases;	1✔
77	}	1✔
78
79	// Test chain: z = (a + b) * c, require 12 bits at z
80	int TestChain() {	1✔
81	int nrOfFailedTestCases = 0;	1✔
82	ExprGraph g;	1✔
83	int a = g.variable("a", 1.0, 10.0);	2✔
84	int b = g.variable("b", 1.0, 10.0);	2✔
85	int c = g.variable("c", 1.0, 10.0);	1✔
86	int sum = g.add(a, b);	1✔
87	int z = g.mul(sum, c);	1✔
88	g.require_nsb(z, 12);	1✔
89	PopSolver solver;	1✔
90	bool ok = solver.solve(g);	1✔
91	VERIFY(ok, "chain LP solver failed");	1✔
92	if (!ok) return nrOfFailedTestCases;	1✔
93	VERIFY(g.get_nsb(z) >= 12, "chain z expected >= 12, got " << g.get_nsb(z));	1✔
94	std::cout << "Chain LP solution:\n";	1✔
95	solver.report(std::cout, g);	1✔
96	return nrOfFailedTestCases;	1✔
97	}	1✔
98
99	// Test empty graph returns false
100	int TestEmptyGraph() {	1✔
101	int nrOfFailedTestCases = 0;	1✔
102	ExprGraph g;	1✔
103	PopSolver solver;	1✔
104	VERIFY(!solver.solve(g), "empty graph should return false");	1✔
105	return nrOfFailedTestCases;	1✔
106	}	1✔
107
108	// Test solver with only variables (no operations)
109	int TestVariablesOnly() {	1✔
110	int nrOfFailedTestCases = 0;	1✔
111	ExprGraph g;	1✔
112	int a = g.variable("a", 1.0, 10.0);	2✔
113	int b = g.variable("b", 1.0, 10.0);	1✔
114	g.require_nsb(a, 8);	1✔
115	g.require_nsb(b, 12);	1✔
116	PopSolver solver;	1✔
117	bool ok = solver.solve(g);	1✔
118	VERIFY(ok, "variables-only LP should succeed");	1✔
119	if (!ok) return nrOfFailedTestCases;	1✔
120	VERIFY(g.get_nsb(a) >= 8, "a expected >= 8, got " << g.get_nsb(a));	1✔
121	VERIFY(g.get_nsb(b) >= 12, "b expected >= 12, got " << g.get_nsb(b));	1✔
122	return nrOfFailedTestCases;	1✔
123	}	1✔
124
125	// Test with requirement on intermediate node
126	int TestIntermediateRequirement() {	1✔
127	int nrOfFailedTestCases = 0;	1✔
128	ExprGraph g;	1✔
129	int a = g.variable("a", 1.0, 10.0);	2✔
130	int b = g.variable("b", 1.0, 10.0);	1✔
131	int sum = g.add(a, b);	1✔
132	int result = g.mul(sum, a);	1✔
133	g.require_nsb(sum, 15);	1✔
134	g.require_nsb(result, 10);	1✔
135	PopSolver solver;	1✔
136	bool ok = solver.solve(g);	1✔
137	VERIFY(ok, "intermediate requirement LP failed");	1✔
138	if (!ok) return nrOfFailedTestCases;	1✔
139	VERIFY(g.get_nsb(sum) >= 15, "intermediate sum expected >= 15, got " << g.get_nsb(sum));	1✔
140	VERIFY(g.get_nsb(result) >= 10, "result expected >= 10, got " << g.get_nsb(result));	1✔
141	return nrOfFailedTestCases;	1✔
142	}	1✔
143
144	// Test solver status and total_nsb accessors
145	int TestSolverAccessors() {	1✔
146	int nrOfFailedTestCases = 0;	1✔
147	ExprGraph g;	1✔
148	int x = g.variable("x", 1.0, 8.0);	2✔
149	int y = g.variable("y", 1.0, 8.0);	1✔
150	int z = g.mul(x, y);	1✔
151	g.require_nsb(z, 10);	1✔
152	PopSolver solver;	1✔
153	solver.solve(g);	1✔
154	VERIFY(solver.status() == LPStatus::Optimal, "status expected Optimal, got " << to_string(solver.status()));	1✔
155	VERIFY(solver.total_nsb() >= 32.0, "total_nsb expected >= 32, got " << solver.total_nsb());	1✔
156	std::ostringstream oss;	1✔
157	solver.report(oss, g);	1✔
158	VERIFY(!oss.str().empty(), "report output should not be empty");	1✔
159	return nrOfFailedTestCases;	1✔
160	}	1✔
161
162	// Test unary operations through PopSolver
163	int TestUnaryOpsSolver() {	1✔
164	int nrOfFailedTestCases = 0;	1✔
165	ExprGraph g;	1✔
166	int x = g.variable("x", 4.0, 16.0);	1✔
167	int nx = g.neg(x);	1✔
168	int ax = g.abs(nx);	1✔
169	int result = g.sqrt(ax);	1✔
170	g.require_nsb(result, 10);	1✔
171	PopSolver solver;	1✔
172	bool ok = solver.solve(g);	1✔
173	VERIFY(ok, "unary ops LP failed");	1✔
174	if (!ok) return nrOfFailedTestCases;	1✔
175	VERIFY(g.get_nsb(result) >= 10, "unary result expected >= 10, got " << g.get_nsb(result));	1✔
176	return nrOfFailedTestCases;	1✔
177	}	1✔
178
179	// Test division through PopSolver
180	int TestDivisionSolver() {	1✔
181	int nrOfFailedTestCases = 0;	1✔
182	ExprGraph g;	1✔
183	int a = g.variable("a", 10.0, 100.0);	2✔
184	int b = g.variable("b", 1.0, 10.0);	1✔
185	int z = g.div(a, b);	1✔
186	g.require_nsb(z, 14);	1✔
187	PopSolver solver;	1✔
188	bool ok = solver.solve(g);	1✔
189	VERIFY(ok, "division LP failed");	1✔
190	if (!ok) return nrOfFailedTestCases;	1✔
191	VERIFY(g.get_nsb(z) >= 14, "div z expected >= 14, got " << g.get_nsb(z));	1✔
192	return nrOfFailedTestCases;	1✔
193	}	1✔
194
195	}} // namespace sw::universal
196
197	#define TEST_CASE(name, func) do { int f_ = func; if (f_) { std::cout << name << ": FAIL (" << f_ << " errors)\n"; nrOfFailedTestCases += f_; } else { std::cout << name << ": PASS\n"; } } while(0)
198
199	int main()	1✔
200	try {
201	using namespace sw::universal;
202	int nrOfFailedTestCases = 0;	1✔
203	std::cout << "POP LP Solver Tests\n" << std::string(40, '=') << "\n\n";	2✔
204
205	TEST_CASE("Simple multiplication LP", TestSimpleMul());	1✔
206	TEST_CASE("Determinant LP", TestDeterminant());	1✔
207	TEST_CASE("Chain LP", TestChain());	1✔
208	TEST_CASE("Empty graph", TestEmptyGraph());	1✔
209	TEST_CASE("Variables only", TestVariablesOnly());	1✔
210	TEST_CASE("Intermediate requirement", TestIntermediateRequirement());	1✔
211	TEST_CASE("Solver accessors", TestSolverAccessors());	1✔
212	TEST_CASE("Unary ops solver", TestUnaryOpsSolver());	1✔
213	TEST_CASE("Division solver", TestDivisionSolver());	1✔
214
215	std::cout << "\n" << (nrOfFailedTestCases == 0 ? "All POP solver tests PASSED" : std::to_string(nrOfFailedTestCases) + " test(s) FAILED") << "\n";	2✔
216	return (nrOfFailedTestCases > 0 ? EXIT_FAILURE : EXIT_SUCCESS);	1✔
217	}
NEW 218	catch (const char* msg) { std::cerr << "Caught exception: " << msg << std::endl; return EXIT_FAILURE; }	×
NEW 219	catch (...) { std::cerr << "Caught unknown exception" << std::endl; return EXIT_FAILURE; }	×

stillwater-sc / universal / 22596488542

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous